Upload folder using huggingface_hub (part 18)

pool/shard000/Python/0007510_save.py

@@ -0,0 +1,42 @@
+import os
+import json
+
+
+class savedparser:
+
+    def __init__(self, saved_path: str):
+
+        if not os.path.isfile(saved_path):
+            raise FileNotFoundError
+
+        self.saved_path = saved_path
+
+    def parse(self):
+
+        with open(self.saved_path, 'r') as save_file:
+            articles = json.load(save_file)
+
+        return articles
+
+    def insert(self, article: dict):
+
+        with open(self.saved_path) as save_file:
+            articles = json.load(save_file)
+
+        ids_old = [a['id'] for a in articles]
+
+        if article['id'] not in ids_old:
+            articles = [article] + articles
+
+        with open(self.saved_path, 'w') as save_file:
+            json.dump(articles, save_file)
+
+    def remove(self, num: int=1):
+
+        with open(self.saved_path) as save_file:
+            articles = json.load(save_file)
+
+        articles = articles[:num-1] + articles[num:]
+
+        with open(self.saved_path, 'w') as save_file:
+            json.dump(articles, save_file)

pool/shard000/Python/0007513_netconns.py

@@ -0,0 +1,114 @@
+# Volatility
+# Copyright (C) 2007-2013 Volatility Foundation
+#
+# This file is part of Volatility.
+#
+# Volatility 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.
+#
+# Volatility 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 Volatility.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""
+@author:       Andrew Case
+@license:      GNU General Public License 2.0
+@contact:      atcuno@gmail.com
+@organization: 
+"""
+
+import volatility.obj as obj
+import volatility.plugins.mac.common as common
+from volatility.renderers import TreeGrid
+from volatility.renderers.basic import Address
+
+class mac_network_conns(common.AbstractMacCommand):
+    """ Lists network connections from kernel network structures """
+
+    # in_pcblookup_hash - bsd/netinet/in_pcb.c 
+    def _walk_pcb_hash(self, proto_pcbinfo):
+        pcb_hash = obj.Object("Array", offset = proto_pcbinfo.hashbase, vm = self.addr_space, targetType = "Pointer", count = proto_pcbinfo.hashmask + 1)
+
+        for pcb_ent in pcb_hash:
+            head = pcb_ent.dereference_as("inpcbhead")
+
+            if not head:
+                continue
+
+            inpcb = head.lh_first.dereference_as("inpcb")
+
+            while inpcb:
+                yield inpcb
+                inpcb = inpcb.inp_hash.le_next 
+
+    # in_pcblookup_hash - bsd/netinet/in_pcb.c 
+    def _walk_pcb_list(self, proto_pcbinfo):
+        inpcb = proto_pcbinfo.listhead.lh_first.dereference_as("inpcb")
+
+        while inpcb:
+            yield inpcb
+            inpcb = inpcb.inp_list.le_next 
+
+    def _walk_pcb_entries(self, inpcbinfo_addr):
+        pcbs = {}
+        
+        inpcbinfo = obj.Object("inpcbinfo", offset = inpcbinfo_addr, vm = self.addr_space)
+
+        for pcbinfo in self._walk_pcb_list(inpcbinfo):
+            pcbs[pcbinfo.obj_offset] = pcbinfo
+    
+        for pcbinfo in self._walk_pcb_hash(inpcbinfo):
+            pcbs[pcbinfo.obj_offset] = pcbinfo
+
+        for pcbinfo in pcbs.values():
+            (lip, lport, rip, rport) = pcbinfo.ipv4_info() 
+            yield (pcbinfo, lip, lport, rip, rport)
+
+    def calculate(self):
+        common.set_plugin_members(self)    
+
+        entries = []
+        
+        tcbinfo_addr   = self.addr_space.profile.get_symbol("_tcbinfo")
+        udbinfo_addr   = self.addr_space.profile.get_symbol("_udbinfo") 
+        ripdbinfo_addr = self.addr_space.profile.get_symbol("_ripcbinfo")
+        
+        info_addrs = [("TCP", tcbinfo_addr), ("UDP", udbinfo_addr), ("RAW", ripdbinfo_addr)]
+
+        for (proto_str, info_addr) in info_addrs:
+            for (pcbinfo, lip, lport, rip, rport) in self._walk_pcb_entries(info_addr):
+                if proto_str == "TCP":
+                    state = pcbinfo.get_tcp_state()
+                else:
+                    state = ""
+                yield (proto_str, pcbinfo, lip, lport, rip, rport, state)
+
+    def unified_output(self, data):
+        return TreeGrid([("Offset (V)", Address),
+                                  ("Protocol", str),
+                                  ("Local IP", str),
+                                  ("Local Port", int),
+                                  ("Remote IP", str),
+                                  ("Remote Port", int),
+                                  ("State", str),
+                                 ], self.generator(data))
+
+    def generator(self, data):
+        for (proto, pcb, lip, lport, rip, rport, state) in data: 
+            yield(0, [
+                Address(pcb.obj_offset),
+                str(proto),
+                str(lip),
+                int(lport),
+                str(rip),
+                int(rport),
+                str(state),
+                ])
+

pool/shard000/Python/0007515_torrent_tests.py

@@ -0,0 +1,76 @@
+import unittest
+
+import sickchill.logger
+from sickchill import settings
+from sickchill.oldbeard.providers import bitcannon, rarbg
+from sickchill.tv import TVEpisode, TVShow
+from tests import test_lib as test
+
+
+class TorrentBasicTests(test.SickChillTestDBCase):
+    """
+    Test torrents
+    """
+    @classmethod
+    def setUpClass(cls):
+        cls.shows = []
+
+        show = TVShow(1, 121361)
+        show.name = "Italian Works"
+        show.episodes = []
+        episode = TVEpisode(show, 5, 10)
+        episode.name = "Pines of Rome"
+        episode.scene_season = 5
+        episode.scene_episode = 10
+        show.episodes.append(episode)
+        cls.shows.append(show)
+
+    def test_bitcannon(self):
+        """
+        Test bitcannon
+        """
+        provider = bitcannon.Provider()
+        provider.custom_url = ""        # true testing requires a valid URL here (e.g., "http://localhost:3000/")
+        provider.api_key = ""
+
+        if provider.custom_url:
+
+            search_strings_list = provider.get_episode_search_strings(self.shows[0].episodes[0])  # [{'Episode': ['Italian Works S05E10']}]
+            for search_strings in search_strings_list:
+                provider.search(search_strings)   # {'Episode': ['Italian Works S05E10']}
+
+        return True
+
+    @unittest.skip('Only run this manually')
+    def test_search(self):
+        """
+        Test searching, using rarbg
+        """
+        settings.CPU_PRESET = 'LOW'
+        provider = rarbg.Provider()
+        results = provider.search({'Episode': ['The Mandalorian S01E08']})
+        self.assertTrue(results)
+        self.assertIn('Mandalorian', results[0]['title'])
+
+        results = provider.search({'RSS': ['']})
+        self.assertTrue(results)
+
+
+if __name__ == "__main__":
+    print("==================")
+    print("STARTING - Torrent Basic TESTS")
+    print("==================")
+    print("######################################################################")
+
+    def override_log(msg, *args, **kwargs):
+        """Override the SickChill logger so we can see the debug output from providers"""
+        _ = args, kwargs
+        print(msg)
+
+    sickchill.logger.info = override_log
+    sickchill.logger.debug = override_log
+    sickchill.logger.error = override_log
+    sickchill.logger.warning = override_log
+
+    SUITE = unittest.TestLoader().loadTestsFromTestCase(TorrentBasicTests)
+    unittest.TextTestRunner(verbosity=2).run(SUITE)

pool/shard000/Python/0007520_dbutils.py

@@ -0,0 +1,65 @@
+#encoding: utf-8
+
+import MySQLdb
+
+import gconf
+
+
+def execute_fetch_sql(sql, args=(), fetch=True):
+    return execute_sql(sql, args, fetch)
+
+def execute_commit_sql(sql, args=(), fetch=False):
+    return execute_sql(sql, args, fetch)
+
+
+def execute_sql(sql, args=(), fetch=True):
+    _conn = None
+    _cur = None
+    _count = 0
+    _rt_list = []
+    try:
+        _conn = MySQLdb.connect(host=gconf.MYSQL_HOST, port=gconf.MYSQL_PORT, \
+                        user=gconf.MYSQL_USER, passwd=gconf.MYSQL_PASSWD, \
+                        db=gconf.MYSQL_DB, charset=gconf.MYSQL_CHARSET)
+
+        #_conn.autocommit(True)              #autocommit
+        _cur = _conn.cursor()
+        _count = _cur.execute(sql, args)
+        if fetch:
+            _rt_list = _cur.fetchall()
+        else:
+            _conn.commit()                      #commit, 和autocommit任选其一
+    except BaseException as e:
+        print e
+    finally:
+        if _cur:
+            _cur.close()
+        if _conn:
+            _conn.close()
+    return _count, _rt_list
+
+def bulker_commit_sql(sql, args_list=[]):
+    _conn = None
+    _cur = None
+    _count = 0
+    _rt_list = []
+    try:
+        _conn = MySQLdb.connect(host=gconf.MYSQL_HOST, port=gconf.MYSQL_PORT, \
+                        user=gconf.MYSQL_USER, passwd=gconf.MYSQL_PASSWD, \
+                        db=gconf.MYSQL_DB, charset=gconf.MYSQL_CHARSET)
+
+        #_conn.autocommit(True)              #autocommit
+        _cur = _conn.cursor()
+        for _args in args_list:
+            print sql, _args
+            _count += _cur.execute(sql, _args)
+        _conn.commit()                      #commit, 和autocommit任选其一
+    except BaseException as e:
+        print e
+    finally:
+        if _cur:
+            _cur.close()
+        if _conn:
+            _conn.close()
+
+    return _count, _rt_list

pool/shard000/Python/0007523_crypto.py

@@ -0,0 +1,88 @@
+# coding=utf-8
+#
+# Copyright 2016 F5 Networks 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.
+#
+"""BIG-IP® system config module
+
+REST URI
+    ``http://localhost/mgmt/tm/sys/config``
+
+GUI Path
+    N/A
+
+REST Kind
+    ``tm:sys:config:*``
+"""
+
+from f5.bigip.resource import Collection
+from f5.bigip.resource import OrganizingCollection
+from f5.bigip.resource import Resource
+
+
+class Crypto(OrganizingCollection):
+    def __init__(self, sys):
+        super(Crypto, self).__init__(sys)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Certs,
+            Keys
+        ]
+
+
+class Keys(Collection):
+    def __init__(self, crypto):
+        super(Keys, self).__init__(crypto)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Key
+        ]
+        self._meta_data['attribute_registry'] =\
+            {'tm:sys:crypto:key:keystate': Key}
+
+    def install_key(self, certfilename, keyfilename):
+        payload =\
+            {"from-local-file": "/var/config/rest/downloads/%s" % keyfilename,
+             "command": "install",
+             "name": certfilename[:-4]}
+        self._meta_data['icr_session'].post(self._meta_data['uri'],
+                                            json=payload)
+
+
+class Key(Resource):
+    def __init__(self, keys):
+        super(Key, self).__init__(keys)
+        self._meta_data['required_json_kind'] = 'tm:sys:crypto:key:keystate'
+
+
+class Certs(Collection):
+    def __init__(self, crypto):
+        super(Certs, self).__init__(crypto)
+        self._meta_data['allowed_lazy_attributes'] = [
+            Cert
+        ]
+        self._meta_data['attribute_registry'] =\
+            {'tm:sys:crypto:cert:certstate': Cert}
+
+    def install_cert(self, certfilename):
+        payload =\
+            {"from-local-file": "/var/config/rest/downloads/%s" % certfilename,
+             "command": "install",
+             "name": certfilename[:-4]}
+        self._meta_data['icr_session'].post(self._meta_data['uri'],
+                                            json=payload)
+
+
+class Cert(Resource):
+    def __init__(self, certs):
+        super(Cert, self).__init__(certs)
+        self._meta_data['required_json_kind'] = 'tm:sys:crypto:cert:certstate'

pool/shard000/Python/0007526_bmn-fastaLenDistribOverlap.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+### 
+
+
+import string
+import copy
+import sys
+from Bio import SeqIO
+from StringIO import StringIO
+import random
+
+fastafile1 = sys.argv[1]
+fastafile2 = sys.argv[2]
+seqs1=[]
+seqs2=[]
+sizes1=[]
+
+handle1 = open(fastafile1)
+for seq_record in SeqIO.parse(handle1, "fasta"):
+	sizes1.append(len(seq_record.seq))
+	seqs1.append(seq_record)
+
+handle1.close()
+
+handle2 = open(fastafile2)
+sizes2 = [len(seq_record.seq) for seq_record in SeqIO.parse(handle2, "fasta")]
+
+handle2.close()
+
+
+def uniq(seq):
+	keys = {}
+	for e in seq:
+		keys[e] = 1
+	return keys.keys()
+
+allSizes=uniq(sizes1+sizes2)
+
+
+
+distrib1={}
+for i in allSizes:
+    distrib1[i]=0
+
+distrib2=copy.deepcopy(distrib1)
+distribCounter1=copy.deepcopy(distrib1)
+distribCounter2=copy.deepcopy(distrib1)
+
+for i in sizes1:
+	distrib1[i]+=1
+
+for j in sizes2:
+	distrib2[j]+=1
+
+distribCommon={}
+for i in allSizes:
+	if min(distrib1[i],distrib2[i])!=0:
+		distribCommon[i]=min(distrib1[i],distrib2[i])
+
+random.shuffle(seqs1)
+
+handleout1 = open(fastafile1+".overlap", "w")
+
+for i in seqs1:
+	seqsize=len(i.seq)
+	if distribCommon.has_key(seqsize):
+		if distribCounter1[seqsize] < distribCommon[seqsize]:
+			SeqIO.write(i, handleout1, "fasta")
+			distribCounter1[seqsize]+=1
+
+handleout1.close()
+
+handle2r = open(fastafile2)
+for seq_record in SeqIO.parse(handle2r, "fasta"):
+	seqs2.append(seq_record)
+handle2r.close()
+
+random.shuffle(seqs2)
+
+handleout2 = open(fastafile2+".overlap", "w")
+
+for i in seqs2:
+	seqsize=len(i.seq)
+	if distribCommon.has_key(seqsize):
+		if distribCounter2[seqsize] < distribCommon[seqsize]:
+			SeqIO.write(i, handleout2, "fasta")
+			distribCounter2[seqsize]+=1
+
+handleout2.close()
+
+
+
+
+
+
+

pool/shard000/Python/0007527_letters.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""This file is part of the prometeo project.
+
+This program 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.
+
+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 Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+"""
+
+__author__ = 'Emanuele Bertoldi <emanuele.bertoldi@gmail.com>'
+__copyright__ = 'Copyright (c) 2011 Emanuele Bertoldi'
+__version__ = '0.0.5'
+
+from django.utils.translation import ugettext_lazy as _
+from django.shortcuts import render_to_response, get_object_or_404
+from django.core.urlresolvers import reverse
+from django.views.generic.simple import redirect_to
+from django.views.generic import list_detail, create_update
+from django.template import RequestContext
+from django.contrib import messages
+
+from prometeo.core.auth.decorators import obj_permission_required as permission_required
+from prometeo.core.views import filtered_list_detail
+from prometeo.documents.models import *
+from prometeo.documents.forms import *
+from prometeo.documents.views import *
+from prometeo.products.forms import ProductEntryFormset
+
+from ..models import *
+from ..forms import *
+
+def _get_letter(request, *args, **kwargs):
+    note_id = kwargs.get('note_id', None)
+    if note_id:
+        return get_object_or_404(Letter, id=note_id)
+    id = kwargs.get('id', None)
+    if id:
+        return get_object_or_404(Letter, id=id)
+    return None
+
+@permission_required('partners.view_letter')
+def letter_list(request, page=0, paginate_by=10, **kwargs):
+    """Shows a letter list.
+    """
+    return filtered_list_detail(
+        request,
+        Document.objects.get_for_content(Letter),
+        fields=['code', 'author', 'created', 'owner'],
+        page=page,
+        paginate_by=paginate_by,
+        template_name='partners/letter_list.html',
+        **kwargs
+    )
+
+@permission_required('partners.add_letter')     
+def letter_add(request, **kwargs):
+    """Adds a new letter.
+    """
+    letter = Letter()
+    doc = Document(author=request.user, content_object=letter)
+      
+    if request.method == 'POST':
+        dform = DocumentForm(request.POST, instance=doc)
+        form = LetterForm(request.POST, instance=letter)
+        if form.is_valid() and dform.is_valid():
+            form.save()
+            doc.content_object = letter 
+            dform.save()
+            messages.success(request, _("The letter was created successfully."))
+            return redirect_to(request, url=doc.get_absolute_url())
+    else:
+        dform = DocumentForm(instance=doc)
+        form = LetterForm(instance=letter)
+
+    return render_to_response('partners/letter_edit.html', RequestContext(request, {'form': form, 'dform': dform, 'object': doc}))
+
+@permission_required('partners.view_letter', _get_letter)     
+def letter_detail(request, id, page=None, **kwargs):
+    """Shows letter details.
+    """
+    object_list = Document.objects.get_for_content(Letter)
+
+    return list_detail.object_detail(
+        request,
+        object_id=object_list.get(object_id=id).pk,
+        queryset=object_list,
+        extra_context={
+            'object_list': object_list,
+        },
+        template_name=kwargs.pop('template_name', 'partners/letter_detail.html'),
+        **kwargs
+    )
+
+@permission_required('partners.change_letter', _get_letter)     
+def letter_edit(request, id, **kwargs):
+    """Edits a letter.
+    """
+    doc = get_object_or_404(Document.objects.get_for_content(Letter), object_id=id)
+    letter = doc.content_object
+      
+    if request.method == 'POST':
+        dform = DocumentForm(request.POST, instance=doc)
+        form = LetterForm(request.POST, instance=letter)
+        if form.is_valid() and dform.is_valid():
+            form.save()
+            dform.save()
+            messages.success(request, _("The letter was updated successfully."))
+            return redirect_to(request, url=doc.get_absolute_url())
+    else:
+        dform = DocumentForm(instance=doc)
+        form = LetterForm(instance=letter)
+
+    return render_to_response('partners/letter_edit.html', RequestContext(request, {'form': form, 'dform': dform, 'object': doc}))
+
+@permission_required('partners.delete_letter', _get_letter)    
+def letter_delete(request, id, **kwargs):
+    """Deletes a letter.
+    """
+    return create_update.delete_object(
+        request,
+        model=Document,
+        object_id=Document.objects.get_for_content(Letter).get(object_id=id).pk,
+        post_delete_redirect=reverse('letter_list'),
+        template_name='partners/letter_delete.html',
+        **kwargs
+    )
+
+@permission_required('partners.view_letter', _get_letter)     
+def letter_hardcopies(request, id, page=0, paginate_by=10, **kwargs):
+    """Shows letter hard copies.
+    """
+    return hardcopy_list(request, Document.objects.get_for_content(Letter).get(object_id=id).pk, page, paginate_by, **kwargs)
+
+@permission_required('partners.change_letter', _get_letter)     
+def letter_add_hardcopy(request, id, **kwargs):
+    """Adds an hard copy to the given document.
+    """
+    return hardcopy_add(request, Document.objects.get_for_content(Letter).get(object_id=id).pk, **kwargs)

pool/shard000/Python/0007528_test_auth_saml2.py

@@ -0,0 +1,176 @@
+from __future__ import absolute_import
+
+import six
+import pytest
+import base64
+import mock
+from exam import fixture
+from six.moves.urllib.parse import urlencode, urlparse, parse_qs
+
+from django.conf import settings
+from django.core.urlresolvers import reverse
+
+from sentry.auth.providers.saml2 import SAML2Provider, Attributes, HAS_SAML2
+from sentry.models import AuthProvider
+from sentry.testutils import AuthProviderTestCase
+from sentry.testutils.helpers import Feature
+
+
+dummy_provider_config = {
+    'idp': {
+        'entity_id': 'https://example.com/saml/metadata/1234',
+        'x509cert': 'foo_x509_cert',
+        'sso_url': 'http://example.com/sso_url',
+        'slo_url': 'http://example.com/slo_url',
+    },
+    'attribute_mapping': {
+        Attributes.IDENTIFIER: 'user_id',
+        Attributes.USER_EMAIL: 'email',
+        Attributes.FIRST_NAME: 'first_name',
+        Attributes.LAST_NAME: 'last_name',
+    },
+}
+
+
+class DummySAML2Provider(SAML2Provider):
+    def get_saml_setup_pipeline(self):
+        return []
+
+    def build_config(self, state):
+        return dummy_provider_config
+
+
+@pytest.mark.skipif(not HAS_SAML2, reason='SAML2 library is not installed')
+class AuthSAML2Test(AuthProviderTestCase):
+    provider = DummySAML2Provider
+    provider_name = 'saml2_dummy'
+
+    def setUp(self):
+        self.user = self.create_user('rick@onehundredyears.com')
+        self.org = self.create_organization(owner=self.user, name='saml2-org')
+        self.auth_provider = AuthProvider.objects.create(
+            provider=self.provider_name,
+            config=dummy_provider_config,
+            organization=self.org,
+        )
+
+        # The system.url-prefix, which is used to generate absolute URLs, must
+        # have a TLD for the SAML2 library to consider the URL generated for
+        # the ACS endpoint valid.
+        self.url_prefix = settings.SENTRY_OPTIONS.get('system.url-prefix')
+
+        settings.SENTRY_OPTIONS.update({
+            'system.url-prefix': 'http://testserver.com',
+        })
+
+        super(AuthSAML2Test, self).setUp()
+
+    def tearDown(self):
+        # restore url-prefix config
+        settings.SENTRY_OPTIONS.update({
+            'system.url-prefix': self.url_prefix,
+        })
+
+        super(AuthSAML2Test, self).tearDown()
+
+    @fixture
+    def login_path(self):
+        return reverse('sentry-auth-organization', args=['saml2-org'])
+
+    @fixture
+    def acs_path(self):
+        return reverse('sentry-auth-organization-saml-acs', args=['saml2-org'])
+
+    @fixture
+    def setup_path(self):
+        return reverse('sentry-organization-auth-settings', args=['saml2-org'])
+
+    def test_redirects_to_idp(self):
+        resp = self.client.post(self.login_path, {'init': True})
+
+        assert resp.status_code == 302
+        redirect = urlparse(resp.get('Location', ''))
+        query = parse_qs(redirect.query)
+
+        assert redirect.path == '/sso_url'
+        assert 'SAMLRequest' in query
+
+    def accept_auth(self, **kargs):
+        saml_response = self.load_fixture('saml2_auth_response.xml')
+        saml_response = base64.b64encode(saml_response)
+
+        # Disable validation of the SAML2 mock response
+        is_valid = 'onelogin.saml2.response.OneLogin_Saml2_Response.is_valid'
+
+        with mock.patch(is_valid, return_value=True):
+            return self.client.post(self.acs_path, {'SAMLResponse': saml_response}, **kargs)
+
+    def test_auth_sp_initiated(self):
+        # Start auth process from SP side
+        self.client.post(self.login_path, {'init': True})
+        auth = self.accept_auth()
+
+        assert auth.status_code == 200
+        assert auth.context['existing_user'] == self.user
+
+    def test_auth_idp_initiated(self):
+        auth = self.accept_auth()
+
+        assert auth.status_code == 200
+        assert auth.context['existing_user'] == self.user
+
+    def test_auth_setup(self):
+        self.auth_provider.delete()
+        self.login_as(self.user)
+
+        data = {'init': True, 'provider': self.provider_name}
+
+        with Feature(['organizations:sso', 'organizations:sso-saml2']):
+            setup = self.client.post(self.setup_path, data)
+
+        assert setup.status_code == 302
+        redirect = urlparse(setup.get('Location', ''))
+        assert redirect.path == '/sso_url'
+
+        auth = self.accept_auth(follow=True)
+
+        messages = map(lambda m: six.text_type(m), auth.context['messages'])
+
+        assert len(messages) == 2
+        assert messages[0] == 'You have successfully linked your account to your SSO provider.'
+        assert messages[1].startswith('SSO has been configured for your organization')
+
+    def test_auth_idp_initiated_no_provider(self):
+        self.auth_provider.delete()
+        auth = self.accept_auth(follow=True)
+
+        assert auth.status_code == 200
+
+        messages = map(lambda m: six.text_type(m), auth.context['messages'])
+        assert len(messages) == 1
+        assert messages[0] == 'The organization does not exist or does not have SAML SSO enabled.'
+
+    def test_saml_metadata(self):
+        path = reverse('sentry-auth-organization-saml-metadata', args=['saml2-org'])
+        resp = self.client.get(path)
+
+        assert resp.status_code == 200
+        assert resp.get('content-type') == 'text/xml'
+
+    def test_logout_request(self):
+        saml_request = self.load_fixture('saml2_slo_request.xml')
+        saml_request = base64.b64encode(saml_request)
+
+        self.login_as(self.user)
+
+        path = reverse('sentry-auth-organization-saml-sls', args=['saml2-org'])
+        path = path + '?' + urlencode({'SAMLRequest': saml_request})
+        resp = self.client.get(path)
+
+        assert resp.status_code == 302
+
+        redirect = urlparse(resp.get('Location', ''))
+        query = parse_qs(redirect.query)
+
+        assert redirect.path == '/slo_url'
+        assert 'SAMLResponse' in query

pool/shard000/Python/0007533_update_illinois.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+
+
+from spider import *
+
+class IllinoisSpider(Spider):
+
+    def __init__(self):
+        Spider.__init__(self)
+        self.school = 'illinois'
+
+    def doWork(self):
+
+        file_name = self.get_file_name('eecs', self.school)
+        file_lines = self.countFileLineNum(file_name)
+        f = self.open_db(file_name + ".tmp")
+        self.count = 0
+
+        r = requests.get('http://ws.engr.illinois.edu/courses/list.asp?mode=timetable&unit=1434&profile=/courses/profile/&groupby=term&term=120151&type=~ind')
+        text = r.text
+        text = text.replace("document.write('", '').replace("');", '').replace("\\", '')
+        soup = BeautifulSoup(text)
+        for div in soup.find_all('div', class_='extCourse'):
+            sp = BeautifulSoup(div.prettify())
+            courseNum = sp.find('div', class_='extCourseRubric').text.replace(' ', '').strip()
+            title = sp.find('div', class_='extCourseTitle').text.strip()
+            link = 'http://cs.illinois.edu/courses/profile/' + courseNum
+            print courseNum + ' ' + title
+            self.count += 1
+            self.write_db(f, courseNum, title, link)
+
+        self.close_db(f)
+        if file_lines != self.count and self.count > 0:
+            self.do_upgrade_db(file_name)
+            print "before lines: " + str(file_lines) + " after update: " + str(self.count) + " \n\n"
+        else:
+            self.cancel_upgrade(file_name)
+            print "no need upgrade\n"
+
+start = IllinoisSpider()
+start.doWork()

pool/shard000/Python/0007542_workspaceSymbol.py

@@ -0,0 +1,53 @@
+from os import path
+import sys
+
+from .base import Base
+
+sys.path.insert(0, path.dirname(path.dirname(__file__)))
+
+from common import (  # isort:skip  # noqa: I100 E402
+    convert_symbols_to_candidates,
+    SYMBOL_CANDIDATE_HIGHLIGHT_SYNTAX,
+    highlight_setup,
+)
+
+
+class Source(Base):
+    def __init__(self, vim):
+        super().__init__(vim)
+        self.vim = vim
+
+        self.name = 'workspaceSymbol'
+        self.kind = 'file'
+
+    def highlight(self):
+        highlight_setup(self, SYMBOL_CANDIDATE_HIGHLIGHT_SYNTAX)
+
+    def gather_candidates(self, context):
+        context['is_interactive'] = True
+        prefix = context['input']
+        bufnr = context['bufnr']
+
+        # This a hack to get around the fact that LanguageClient APIs
+        # work in the context of the active buffer, when filtering results
+        # interactively, the denite buffer is the active buffer and it doesn't
+        # have a language server asscosiated with it.
+        # We just switch to the buffer that initiated the denite transaction
+        # and execute the command from it. This should be changed when we
+        # have a better way to run requests out of the buffer.
+        # See issue#674
+        current_buffer = self.vim.current.buffer.number
+        if current_buffer != bufnr:
+            self.vim.command("tabedit %")
+            self.vim.command(
+                "execute 'noautocmd keepalt buffer' {}".format(bufnr))
+        result = self.vim.funcs.LanguageClient_runSync(
+            'LanguageClient#workspace_symbol', prefix, {}) or []
+        if current_buffer != bufnr:
+            self.vim.command("tabclose")
+
+        candidates = convert_symbols_to_candidates(
+            result,
+            pwd=self.vim.funcs.getcwd())
+
+        return candidates

pool/shard000/Python/0007547_setup.py

@@ -0,0 +1,37 @@
+# -*- coding: UTF-8 -*-
+
+from distutils.core import setup
+
+# http://stackoverflow.com/a/7071358/735926
+import re
+VERSIONFILE='omitempty/__init__.py'
+verstrline = open(VERSIONFILE, 'rt').read()
+VSRE = r'^__version__\s+=\s+[\'"]([^\'"]+)[\'"]'
+mo = re.search(VSRE, verstrline, re.M)
+if mo:
+    verstr = mo.group(1)
+else:
+    raise RuntimeError("Unable to find version string in %s." % VERSIONFILE)
+
+setup(
+    name='omitempty',
+    version=verstr,
+    author='Baptiste Fontaine',
+    author_email='b@ptistefontaine.fr',
+    packages=['omitempty'],
+    url='https://github.com/bfontaine/omitempty',
+    license=open('LICENSE', 'r').read(),
+    description='enums for Python',
+    long_description="""\
+omitempty is a Golang's omitempty equivalent for Python""",
+    classifiers=[
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Intended Audience :: Developers',
+        'Operating System :: OS Independent',
+    ],
+)

pool/shard000/Python/0007548_estemplateresponsewriter.py

@@ -0,0 +1,116 @@
+from types import *
+import logging
+import urllib
+import json
+from collections import OrderedDict
+
+from edge.httputility import HttpUtility
+from edge.writer.templateresponsewriter import TemplateResponseWriter
+
+class ESTemplateResponseWriter(TemplateResponseWriter):
+    def __init__(self, configFilePath, requiredParams = None):
+        super(ESTemplateResponseWriter, self).__init__(configFilePath, requiredParams)
+        self.searchParameters = {}
+        self.variables = {}
+        self.facet = False
+        self.facetDefs = {}
+        self.contentType = 'application/xml'
+
+    def get(self, requestHandler):
+        super(ESTemplateResponseWriter, self).get(requestHandler)
+
+        startIndex = 0
+        try:
+            startIndex = requestHandler.get_argument('startIndex')
+            self.searchParameters['startIndex'] = startIndex
+        except:
+            pass
+
+        entriesPerPage = self._configuration.getint('solr', 'entriesPerPage')
+        try:
+            entriesPerPage = requestHandler.get_argument('itemsPerPage')
+            maxEntriesPerPage = self._configuration.getint('solr', 'maxEntriesPerPage')
+            if (int(entriesPerPage) > maxEntriesPerPage):
+                entriesPerPage = maxEntriesPerPage
+            self.searchParameters['itemsPerPage'] = entriesPerPage
+        except:
+            pass
+
+        try:
+            if requestHandler.get_argument('pretty').lower() == 'true':
+                self.pretty = True
+                self.searchParameters['pretty'] = 'true'
+        except:
+            pass
+
+        parameters = {}
+        for parameter in self._configuration.get('solr', 'parameters').split(','):
+            try:
+                value = requestHandler.get_arguments(parameter)
+                if len(value) == 1:
+                    parameters[parameter] = value[0]
+                    self.searchParameters[parameter] = value[0]
+                elif len(value) > 0:
+                    parameters[parameter] = value
+                    self.searchParameters[parameter] = value
+            except:
+                pass
+
+        facets = {}
+        if self._configuration.has_option('solr', 'facets'):
+            self.facetDefs = json.loads(self._configuration.get('solr', 'facets'), object_pairs_hook=OrderedDict)
+            for facet in self.facetDefs.keys():
+                try:
+                    value = requestHandler.get_arguments(facet)
+                    if len(value) > 0:
+                        facets[self.facetDefs[facet]] = value
+                        self.searchParameters[facet] = value
+                except:
+                    pass
+
+        try:
+            self._getResponse(startIndex, entriesPerPage, parameters, facets)
+        except:
+            logging.exception('Failed to get solr response.')
+
+    def _urlEncodeSolrQueryValue(self, value):
+        return urllib.quote('"'+value+'"')
+
+    def _onResponse(self, response):
+        logging.debug(response)
+        if response.error:
+            self._handleException(str(response.error))
+        else:
+            self._writeResponse(response.body)
+
+    def _writeResponse(self, responseText):
+        searchText = ''
+        if 'keyword' in self.variables:
+            searchText = self.variables['keyword']
+        try:
+            openSearchResponse = self._generateOpenSearchResponse(
+                responseText,
+                searchText,
+                self._configuration.get('service', 'url') + self.requestHandler.request.path,
+                self.searchParameters,
+                self.pretty
+            )
+            self.requestHandler.set_header("Content-Type", self.contentType)
+            self.requestHandler.set_header('Access-Control-Allow-Origin', '*')
+            self.requestHandler.write(openSearchResponse)
+            self.requestHandler.finish()
+        except BaseException as exception:
+            self._handleException(str(exception))
+
+    def _getResponse(self, startIndex, entriesPerPage, parameters, facets):
+        query = self._constructQuery(startIndex, entriesPerPage, parameters, facets)
+        url = self._configuration.get('solr', 'datasetUrl')
+
+        httpUtility = HttpUtility()
+        httpUtility.getResponse(url+'/_search/?'+query, self._onResponse)
+
+    def _generateOpenSearchResponse(self, solrResponse, searchText, searchUrl, searchParams, pretty):
+        pass
+
+    def _constructQuery(self, startIndex, entriesPerPage, parameters, facets):
+        pass

pool/shard000/Python/0007550_0043_meta_update_project_links_and_machinerequest_new_version_membership.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0042_add_external_link_and_project_resources'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='machinerequest',
+            name='new_version_membership',
+            field=models.ManyToManyField(to='core.Group', blank=True),
+        ),
+        migrations.AlterModelTable(
+            name='projectexternallink',
+            table='project_links',
+        ),
+    ]

pool/shard000/Python/0007554_test_vtk_file_reader.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2015,  Enthought, Inc.
+# License: BSD Style.
+
+# Standard library imports.
+import unittest
+
+# External library imports
+import vtk
+
+# Enthought library imports
+from mayavi.sources.vtk_file_reader import VTKFileReader
+
+# Local imports.
+from .common import get_example_data
+
+vtk_major_version = vtk.vtkVersion.GetVTKMajorVersion()
+vtk_minor_version = vtk.vtkVersion.GetVTKMinorVersion()
+
+class TestVTKFileReader(unittest.TestCase):
+    def setUp(self):
+        # Read a VTK data file.
+        self.src = VTKFileReader()
+
+    def tearDown(self):
+        """For necessary clean up, automatically called by TestCase
+           after the test methods have been invoked"""
+        self.src = None
+        return
+
+    def check(self, n_points, n_cells):
+        """Do the actual testing."""
+        output = self.src.outputs[0]
+        self.assertEqual(output.number_of_points, n_points)
+        self.assertEqual(output.number_of_cells, n_cells)
+
+    def test_structured_points_file(self):
+        self.src.initialize(get_example_data('texThres2.vtk'))
+        self.check(128, 127)
+
+    def test_rectiliner_grid_file(self):
+        self.src.initialize(get_example_data('RectGrid2.vtk'))
+        self.check(17061, 14720)
+
+    def test_polydata_file(self):
+        self.src.initialize(get_example_data('polyEx.vtk'))
+        self.check(8, 6)
+
+    def test_structured_grid_file(self):
+        self.src.initialize(get_example_data('SampleStructGrid.vtk'))
+        self.check(24000, 21489)
+
+    @unittest.skipIf(vtk_major_version == 5 and vtk_minor_version < 10,
+                    "This test is probably broken in VTK < 5.10")
+    def test_unstructured_grid_file(self):
+        self.src.initialize(get_example_data('UGridEx.vtk'))
+        self.check(27, 12)
+
+    def test_field_file(self):
+        self.src.initialize(get_example_data('fieldfile.vtk'))
+        self.check(18, 3)
+
+if __name__ == '__main__':
+    unittest.main()

pool/shard000/Python/0007558_init__.py

@@ -0,0 +1,123 @@
+# Copyright 2013 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.
+
+# shared resources and global variables
+from tailbone import AppError
+from tailbone import PREFIX
+from tailbone import as_json
+from tailbone import BreakError
+from tailbone import config
+from tailbone import DEBUG
+from tailbone import restful
+
+import re
+import urllib
+import webapp2
+
+HAS_PIL = True
+try:
+  import PIL
+  from google.appengine.api.images import delete_serving_url
+  from google.appengine.api.images import get_serving_url_async
+except:
+  HAS_PIL = False
+
+from google.appengine.ext.ndb import blobstore
+from google.appengine.ext import blobstore as bs
+from google.appengine.ext.webapp import blobstore_handlers
+from google.appengine.api import lib_config
+
+class _ConfigDefaults(object):
+  CLOUDSTORE = None
+
+_config = lib_config.register('tailboneFiles', _ConfigDefaults.__dict__)
+
+
+re_image = re.compile(r"image/(png|jpeg|jpg|webp|gif|bmp|tiff|ico)", re.IGNORECASE)
+
+
+class BlobInfo(blobstore.BlobInfo):
+  def to_dict(self, *args, **kwargs):
+    result = super(BlobInfo, self).to_dict(*args, **kwargs)
+    result["Id"] = str(self.key())
+    return result
+
+
+def blob_info_to_dict(blob_info):
+  d = {}
+  for prop in ["content_type", "creation", "filename", "size"]:
+    d[prop] = getattr(blob_info, prop)
+  key = blob_info.key()
+  if HAS_PIL and re_image.match(blob_info.content_type):
+    d["image_url"] = get_serving_url_async(key)
+  d["Id"] = str(key)
+  return d
+
+
+class FilesHandler(blobstore_handlers.BlobstoreDownloadHandler):
+
+  @as_json
+  def get(self, key):
+    if key == "":  # query
+      if not config.is_current_user_admin():
+        raise AppError("User must be administrator.")
+      return restful.query(self, BlobInfo)
+    elif key == "create":
+      #, gs_bucket_name=_config.CLOUDSTORE)
+      return {
+          "upload_url": blobstore.create_upload_url("/api/files/upload")
+      }
+    key = str(urllib.unquote(key))
+    blob_info = bs.BlobInfo.get(key)
+    if blob_info:
+      self.send_blob(blob_info)
+      raise BreakError
+    else:
+      self.error(404)
+      return {"error": "File not found with key " + key}
+
+  @as_json
+  def post(self, _):
+    raise AppError("You must make a GET call to /api/files/create to get a POST url.")
+
+  @as_json
+  def put(self, _):
+    raise AppError("PUT is not supported for the files api.")
+
+  @as_json
+  def delete(self, key):
+    if not config.is_current_user_admin():
+      raise AppError("User must be administrator.")
+    key = blobstore.BlobKey(str(urllib.unquote(key)))
+    blob_info = BlobInfo.get(key)
+    if blob_info:
+      blob_info.delete()
+      if HAS_PIL and re_image.match(blob_info.content_type):
+        delete_serving_url(key)
+      return {}
+    else:
+      self.error(404)
+      return {"error": "File not found with key " + key}
+
+
+class FilesUploadHandler(blobstore_handlers.BlobstoreUploadHandler):
+  @as_json
+  def post(self):
+    return [blob_info_to_dict(b) for b in self.get_uploads()]
+
+
+app = webapp2.WSGIApplication([
+  (r"{}files/upload".format(PREFIX), FilesUploadHandler),
+  (r"{}files/?(.*)".format(PREFIX), FilesHandler),
+], debug=DEBUG)

pool/shard000/Python/0007563_init__.py

@@ -0,0 +1,62 @@
+"""
+  Copyright (c) 2006 Jan-Klaas Kollhof
+
+  This file is part of jsonrpc.
+
+  jsonrpc 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.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with this software; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""
+
+from pyjs.jsonrpc import JSONRPCServiceBase, jsonremote
+import sys, os
+import Cookie
+
+def read_data():
+    try:
+        contLen=int(os.environ['CONTENT_LENGTH'])
+        data = sys.stdin.read(contLen)
+    except:
+        data = ""
+    return data
+
+def write_data(data, cookies):
+    if not isinstance(data, list):
+        data = [data]
+    data = "\n".join(data)
+    response = "Content-Type: text/plain\n"
+    if cookies:
+        response += cookies+"\n"
+    response += "Content-Length: %d\n\n" % len(data)
+    response += data
+
+    #on windows all \n are converted to \r\n if stdout is a terminal and
+    # is not set to binary mode :(
+    #this will then cause an incorrect Content-length.
+    #I have only experienced this problem with apache on Win so far.
+    if sys.platform == "win32":
+        import  msvcrt
+        msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+    #put out the response
+    sys.stdout.write(response)
+
+class CGIJSONRPCService(JSONRPCServiceBase):
+    def set_cookies(self, c):
+        self._cookies = c
+
+    def __call__(self):
+        self._cookies = Cookie.SmartCookie()
+        self._cookies.load(os.environ.get('HTTP_COOKIE', ''))
+        d = read_data() # TODO: handle partial data
+        write_data(self.process(d), self._cookies.output())
+

pool/shard000/Python/0007564_test_consumers.py

@@ -0,0 +1,216 @@
+# Copyright (c) 2014 Rackspace, 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 copy
+
+from testtools import testcase
+
+from functionaltests.api import base
+from functionaltests.api.v1.behaviors import consumer_behaviors
+from functionaltests.api.v1.behaviors import container_behaviors
+from functionaltests.api.v1.behaviors import secret_behaviors
+from functionaltests.api.v1.models import consumer_model
+from functionaltests.api.v1.models import container_models
+from functionaltests.api.v1.models import secret_models
+
+create_secret_data = {
+    "name": "AES key",
+    "expiration": "2018-02-28T19:14:44.180394",
+    "algorithm": "aes",
+    "bit_length": 256,
+    "mode": "cbc",
+    "payload": "gF6+lLoF3ohA9aPRpt+6bQ==",
+    "payload_content_type": "application/octet-stream",
+    "payload_content_encoding": "base64",
+}
+
+default_consumer_data = {
+    "name": "consumername",
+    "URL": "consumerURL"
+}
+
+create_container_data = {
+    "name": "containername",
+    "type": "generic",
+    "secret_refs": [
+        {
+            "name": "secret1",
+        },
+        {
+            "name": "secret2",
+        }
+    ]
+}
+
+
+class ConsumersTestCase(base.TestCase):
+    default_data = default_consumer_data
+
+    def _create_a_secret(self):
+        secret_model = secret_models.SecretModel(**create_secret_data)
+        resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
+        self.assertEqual(resp.status_code, 201)
+        self.assertIsNotNone(secret_ref)
+
+        return secret_ref
+
+    def setUp(self):
+        super(ConsumersTestCase, self).setUp()
+        self.secret_behaviors = secret_behaviors.SecretBehaviors(self.client)
+        self.container_behaviors = container_behaviors.ContainerBehaviors(
+            self.client
+        )
+        self.consumer_behaviors = consumer_behaviors.ConsumerBehaviors(
+            self.client
+        )
+
+        self.consumer_data = copy.deepcopy(self.default_data)
+
+        # Set up two secrets
+        secret_ref_1 = self._create_a_secret()
+        secret_ref_2 = self._create_a_secret()
+
+        # Create a container with our secrets
+        create_container_data['secret_refs'][0]['secret_ref'] = secret_ref_1
+        create_container_data['secret_refs'][1]['secret_ref'] = secret_ref_2
+        container_model = container_models.ContainerModel(
+            **create_container_data
+        )
+
+        resp, container_ref = self.container_behaviors.create_container(
+            container_model
+        )
+        self.assertEqual(resp.status_code, 201)
+        self.assertIsNotNone(container_ref)
+        self.container_ref = container_ref
+
+    def tearDown(self):
+        self.secret_behaviors.delete_all_created_secrets()
+        super(ConsumersTestCase, self).tearDown()
+
+    @testcase.attr('positive')
+    def test_create_consumer_defaults(self):
+        """Covers consumer creation.
+
+        All of the data needed to create the consumer is provided in a
+        single POST.
+        """
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+    @testcase.attr('positive')
+    def test_get_consumer_defaults(self):
+        """Tests getting a list of consumers for a container."""
+        # Create first consumer
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Create second consumer
+        test_model.name = "consumername2"
+        test_model.URL = "consumerURL2"
+
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Get list of consumers
+        resp, consumers, nref, pref = self.consumer_behaviors.get_consumers(
+            self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn("consumername", consumers[0].name)
+        self.assertIn("consumername2", consumers[1].name)
+
+    @testcase.attr('positive')
+    def test_delete_consumer_defaults(self):
+        """Covers consumer deletion.
+
+        A consumer is first created, and then the consumer is deleted and
+        verified to no longer exist.
+        """
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Delete the consumer
+        resp, consumer_data = self.consumer_behaviors.delete_consumer(
+            test_model, self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertNotIn(test_model.name, consumer_data)
+        self.assertNotIn(test_model.URL, consumer_data)
+
+    @testcase.attr('positive')
+    def test_recreate_consumer_defaults(self):
+        """Covers consumer recreation."""
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Delete the consumer
+        resp, consumer_data = self.consumer_behaviors.delete_consumer(
+            test_model, self.container_ref
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertNotIn(test_model.name, consumer_data)
+        self.assertNotIn(test_model.URL, consumer_data)
+
+        # Register the consumer again
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+    @testcase.attr('positive')
+    def test_create_consumer_defaults_is_idempotent(self):
+        """Covers checking that create consumer is idempotent."""
+        # Register the consumer once
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+
+        # Register the consumer again, without deleting it first
+        test_model = consumer_model.ConsumerModel(**self.consumer_data)
+        resp, consumer_data = self.consumer_behaviors.create_consumer(
+            test_model, self.container_ref)
+
+        count = consumer_data.count(self.consumer_data)
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(consumer_data)
+        self.assertIn(self.consumer_data, consumer_data)
+        self.assertEqual(1, count)

pool/shard000/Python/0007579_tasks.py

@@ -0,0 +1,110 @@
+from mediacrush.config import _cfgi
+from mediacrush.paths import file_storage
+from mediacrush.objects import RedisObject, File, FailedFile, Album
+from mediacrush.celery import app, get_task_logger, chord, signature
+from mediacrush.processing import processor_table, detect
+from mediacrush.fileutils import compression_rate, delete_file
+
+import time
+import os
+import json
+
+from subprocess import call
+
+logger = get_task_logger(__name__)
+
+@app.task
+def zip_album(h):
+    a = Album.from_hash(h)
+    paths = map(lambda f: file_storage(f.original), a.items)
+    zip_path = file_storage(h + ".zip")
+
+    if os.path.exists(zip_path):
+        return
+
+    call(["zip", "-j", zip_path] + paths)
+
+    a.metadata = json.dumps({"has_zip": True})
+    a.save()
+
+@app.task(bind=True, track_started=True)
+def convert_file(self, h, path, p, metadata, processor_state, ignore_limit):
+    f = File.from_hash(h)
+
+    if p not in processor_table:
+        p = 'default'
+
+    processor = processor_table[p](path, f, processor_state, ignore_limit)
+
+    # Execute the synchronous step.
+    processor.sync()
+
+    # Save compression information
+    f = File.from_hash(h) # Reload file; user might have changed the config vector while processing
+    f.compression = compression_rate(path, f)
+    f.metadata = json.dumps(metadata)
+    f.save()
+
+    # Notify frontend: sync step is done.
+    self.update_state(state="READY")
+
+    # Execute the asynchronous step.
+    processor.important = False
+    processor.async()
+
+@app.task
+def cleanup(results, path, h):
+    f = File.from_hash(h)
+    os.unlink(path)
+
+    if f.status in ["internal_error", "error", "timeout", "unrecognised"]:
+        failed = FailedFile(hash=h, status=f.status) # Create a "failed file" record
+        failed.save()
+
+        delete_file(f)
+
+@app.task
+def process_file(path, h, ignore_limit):
+    t = time.time() + 2
+    while True:
+        f = File.from_hash(h)
+        if f or time.time() > t:
+            break
+        time.sleep(0.05) # Wait for Redis to catch up
+
+    try:
+        result = detect(path)
+        processor = result['type'] if result else 'default'
+    except:
+        processor = 'default'
+    finally:
+        if processor == 'default': # Unrecognised file type
+            failed = FailedFile(hash=h, status="unrecognised")
+            failed.save()
+
+            delete_file(f)
+            return
+
+    metadata = result['metadata'] if result else {}
+    processor_state = result['processor_state'] if result else {}
+
+    f.processor = processor
+    queue = "priority" if processor.startswith("image") else "celery"
+
+    setattr(f.flags, 'nsfw', False)
+    if result and result['flags']:
+        for flag, value in result['flags'].items():
+            setattr(f.flags, flag, value)
+
+    f.save()
+
+    args = [h, path, processor, metadata, processor_state, ignore_limit]
+    task = signature("mediacrush.tasks.convert_file", args=args, options={'queue': queue})
+    task_result = task.freeze() # This sets the taskid, so we can pass it to the UI
+
+    # This chord will execute `syncstep` and `asyncstep`, and `cleanup` after both of them have finished.
+    c = chord(task, cleanup.s(path, h))
+    c.apply_async()
+
+    f.taskid = task_result.id
+    f.save()

pool/shard000/Python/0007583_variable_replace_test.py

@@ -0,0 +1,56 @@
+# coding=utf-8
+# Copyright 2022 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.
+
+# python3
+"""Tests for task_set.variable_replace."""
+
+import sonnet as snt
+
+from task_set import variable_replace
+import tensorflow.compat.v1 as tf
+
+
+class VaraibleReplaceTest(tf.test.TestCase):
+
+  def test_variable_replace_getter(self):
+    with self.test_session() as sess:
+      context = variable_replace.VariableReplaceGetter()
+      mod = snt.Linear(1, custom_getter=context)
+
+      inp_data = tf.ones([10, 1])
+      with context.use_variables():
+        y1 = mod(inp_data)
+        sess.run(tf.initialize_all_variables())
+        np_y1 = sess.run(y1)
+
+      values = context.get_variable_dict()
+
+      new_values = {k: v + 1 for k, v in values.items()}
+
+      with context.use_value_dict(new_values):
+        np_y2 = mod(inp_data).eval()
+
+      self.assertNear((np_y2 - np_y1)[0], 2, 1e-8)
+
+      for v in values.values():
+        v.assign(v + 1).eval()
+
+      with context.use_variables():
+        np_y3 = mod(inp_data).eval()
+        self.assertNear((np_y3 - np_y2)[0], 0, 1e-8)
+
+
+if __name__ == '__main__':
+  tf.test.main()

pool/shard000/Python/0007594_judge.py

@@ -0,0 +1,133 @@
+#! /usr/bin/env python
+#-*- coding: utf8 -*-
+
+from six import itervalues
+from math import ceil
+from settings import LANGUAGES, NODE
+from sandbox import Sandbox
+from result import Result
+import threading
+import logging
+
+
+class Judge(threading.Thread):
+    """Compiles, executes and checks solutions for a specific task."""
+
+    def __init__(self, task, submission):
+        self.task = task
+        self.language = submission['language']
+        fileName = LANGUAGES[self.language].get('sourceFilename')
+        if callable(fileName):
+            fileName = fileName(submission['source'])
+        self.fileFullName = fileName
+        self.fileName, self.fileExtension = fileName.split('.')
+        self._results = []
+        self._compilation_log = None
+        self.source = submission['source']
+
+        # If the submission was sent in an active contest
+        # judge sample tests only
+        self.sampleTests = bool(int(submission['active']))
+        threading.Thread.__init__(self)
+
+    def run(self):
+        """Process the judge request - create the sandbox,
+        compile the source, execute and generate results."""
+
+        with Sandbox.new() as sandbox:
+            with sandbox.file(self.fileFullName) as sourceFile:
+                sourceFile.write(self.source)
+            self.compile(sandbox)
+            self.execute(sandbox)
+
+    def compare_files(self, out, ref=None):
+        """Basic comparation function.
+        Compares output file with reference file."""
+
+        out = out.rstrip()
+        ref = ref.rstrip()
+        out = out.split('\n')
+        ref = ref.split('\n')
+        if len(out) != len(ref):
+            return False
+        for outLine, refLine in zip(out, ref):
+            if outLine.rstrip() != refLine.rstrip():
+                return False
+        return True
+
+    def check_solution(self, out, ref=None, fun=compare_files):
+        """Compare solution with chosen function."""
+        return fun(self, out, ref)
+
+    def compile(self, sandbox):
+        """Compile source code and save compile logs"""
+        logging.info("Compiling the submission source.")
+        cmd = '{compiler} {compilerOptions} {fileName}.{fileExtension}'.format(
+            compiler=LANGUAGES[self.language].get('compiler'),
+            compilerOptions=LANGUAGES[self.language].get('compilerOptions'),
+            fileName=self.fileName,
+            fileExtension=self.fileExtension
+        )
+
+        ret = sandbox.execute(
+            cmd,
+            None,
+            timeLimit=NODE['SANDBOX']['COMPILER_TIMELIMIT']
+        )
+
+        self._compilation_log = u'{} {}'.format(*ret[0])
+        logging.info("Compilation finished.")
+
+    def execute(self, sandbox):
+        """Run program with all tests available for specific task
+        and compare using check_solution. Program is limited by execution time
+        and memory depending od information taken from the task."""
+        logging.info("Executing the submission.")
+        executionPath = LANGUAGES[self.language].get('runCommand').format(
+            fileName=self.fileName,
+            fileExtension=self.fileExtension,
+            sandboxHome=NODE['SANDBOX']['HOME_DIR'],
+        )
+
+        for test in itervalues(self.task.tests):
+            if not test.isSampleTest and self.sampleTests:
+                continue
+
+            (out, err), returncode, runTime = sandbox.execute(
+                executionPath,
+                test.input,
+                timeLimit=int(ceil(test.timeLimit)),
+                memoryLimit=test.memoryLimit
+            )
+
+            if not returncode == 0:
+                runTime = 0
+
+            if runTime > test.timeLimit:
+                returncode = 9
+
+            res = Result(
+                returncode,
+                int(self.check_solution(out, test.output) and returncode != 9),
+                runTime)
+            del out
+            self._results.append(res)
+        logging.info("Execution finished.")
+
+        if err:
+            logging.warning("There were errors during execution:\n{}".format(
+                err
+            ))
+
+    @property
+    def results(self):
+        """Return compiler logs and results"""
+        if len(self._results) == 0:
+            return None
+        return self._results
+
+    @property
+    def compilation_log(self):
+        if not self._compilation_log:
+            return None
+        return self._compilation_log

pool/shard000/Python/0007595_test_fact.py

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+# vim: ts=4 sw=4 expandtab ai
+"""Test class for Fact  CLI"""
+
+from ddt import ddt
+from fauxfactory import gen_string
+from robottelo.cli.fact import Fact
+from robottelo.common.decorators import data, run_only_on, stubbed
+from robottelo.test import CLITestCase
+
+
+@run_only_on('sat')
+@ddt
+class TestFact(CLITestCase):
+    """Fact related tests."""
+
+    @stubbed('Need to create facts before we can check them.')
+    @data(
+        'uptime', 'uptime_days', 'uptime_seconds', 'memoryfree', 'ipaddress',
+    )
+    def test_list_success(self, fact):
+        """@Test: Test Fact List
+
+        @Feature: Fact - List Positive
+
+        @Assert: Fact List is displayed
+
+        """
+
+        args = {
+            'search': "fact='%s'" % fact,
+        }
+
+        result = Fact().list(args)
+        stdout = result.stdout
+
+        self.assertEqual(stdout[0]['fact'], fact)
+
+    @data(
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+        gen_string("alpha", 10),
+    )
+    def test_list_fail(self, fact):
+        """@Test: Test Fact List failure
+
+        @Feature: Fact - List Negative
+
+        @Assert: Fact List is not displayed
+
+        """
+
+        args = {
+            'search': "fact='%s'" % fact,
+        }
+        self.assertEqual(
+            Fact().list(args).stdout, [], "No records should be returned")

pool/shard000/Python/0007596_test_loadables.py

@@ -0,0 +1,113 @@
+# Copyright 2012 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.
+"""
+Tests For Loadable class handling.
+"""
+
+from zun.common import exception
+from zun.tests import base
+from zun.tests.unit.scheduler import fake_loadables
+
+
+class LoadablesTestCase(base.TestCase):
+    def setUp(self):
+        super(LoadablesTestCase, self).setUp()
+        self.fake_loader = fake_loadables.FakeLoader()
+        # The name that we imported above for testing
+        self.test_package = 'zun.tests.unit.scheduler.fake_loadables'
+
+    def test_loader_init(self):
+        self.assertEqual(self.fake_loader.package, self.test_package)
+        # Test the path of the module
+        ending_path = '/' + self.test_package.replace('.', '/')
+        self.assertTrue(self.fake_loader.path.endswith(ending_path))
+        self.assertEqual(self.fake_loader.loadable_cls_type,
+                         fake_loadables.FakeLoadable)
+
+    def _compare_classes(self, classes, expected):
+        class_names = [cls.__name__ for cls in classes]
+        self.assertEqual(set(class_names), set(expected))
+
+    def test_get_all_classes(self):
+        classes = self.fake_loader.get_all_classes()
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass5',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass5']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_underscore(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2._FakeLoadableSubClass7']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_wrong_type1(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass4',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_wrong_type2(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.FakeLoadableSubClass1',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass8']
+        self.assertRaises(exception.ClassNotFound,
+                          self.fake_loader.get_matching_classes,
+                          test_classes)
+
+    def test_get_matching_classes_with_one_function(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_valid_classes',
+                        prefix + '.fake_loadable2.FakeLoadableSubClass5']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass5']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_two_functions(self):
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_valid_classes',
+                        prefix + '.fake_loadable2.return_valid_class']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                'FakeLoadableSubClass2',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)
+
+    def test_get_matching_classes_with_function_including_invalids(self):
+        # When using a method, no checking is done on valid classes.
+        prefix = self.test_package
+        test_classes = [prefix + '.fake_loadable1.return_invalid_classes',
+                        prefix + '.fake_loadable2.return_valid_class']
+        classes = self.fake_loader.get_matching_classes(test_classes)
+        expected_class_names = ['FakeLoadableSubClass1',
+                                '_FakeLoadableSubClass3',
+                                'FakeLoadableSubClass4',
+                                'FakeLoadableSubClass6']
+        self._compare_classes(classes, expected_class_names)

pool/shard000/Python/0007601_setup.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#    Copyright (C) 2011 Cédric Krier
+
+#    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 setuptools import setup
+import re
+import os
+import ConfigParser
+
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname)).read()
+
+config = ConfigParser.ConfigParser()
+config.readfp(open('tryton.cfg'))
+info = dict(config.items('tryton'))
+
+for key in ('depends', 'extras_depend', 'xml'):
+    if key in info:
+        info[key] = info[key].strip().splitlines()
+major_version, minor_version = 3, 8
+
+requires = []
+
+for dep in info.get('depends', []):
+    if dep.startswith('health'):
+        requires.append('trytond_%s == %s' %
+            (dep, info.get('version')))
+    elif not re.match(r'(ir|res|webdav)(\W|$)', dep):
+        requires.append('trytond_%s >= %s.%s, < %s.%s' %
+            (dep, major_version, minor_version, major_version,
+                minor_version + 1))
+requires.append('trytond >= %s.%s, < %s.%s' %
+    (major_version, minor_version, major_version, minor_version + 1))
+
+setup(name='trytond_health_crypto',
+    version=info.get('version', '0.0.1'),
+    description=info.get('description', 'GNU Health Cryptography Module'),
+    author=info.get('author', 'GNU Solidario'),
+    author_email=info.get('email', 'health@gnusolidario.org'),
+    url=info.get('website', 'http://health.gnu.org/'),
+    download_url='http://ftp.gnu.org/gnu/health/',
+    package_dir={'trytond.modules.health_crypto': '.'},
+    packages=[
+        'trytond.modules.health_crypto',
+        ],
+    package_data={
+        'trytond.modules.health_crypto': info.get('xml', []) \
+            + info.get('translation', []) \
+            + ['tryton.cfg', 'view/*.xml', 'doc/*.rst', 'locale/*.po',
+               'report/*.odt', 'icons/*.svg'],
+        },
+
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Plugins',
+        'Framework :: Tryton',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Healthcare Industry',
+        'License :: OSI Approved :: GNU General Public License (GPL)',
+        'Natural Language :: English',
+        'Natural Language :: Spanish',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 2.7',
+        'Topic :: Scientific/Engineering :: Bio-Informatics',
+        'Topic :: Scientific/Engineering :: Medical Science Apps.',
+        ],
+    license='GPL-3',
+    install_requires=requires,
+    zip_safe=False,
+    entry_points="""
+    [trytond.modules]
+    health_crypto = trytond.modules.health_crypto
+    """,
+    test_suite='tests',
+    test_loader='trytond.test_loader:Loader',
+    )

pool/shard000/Python/0007604_dummy.py

@@ -0,0 +1,147 @@
+# Copyright 2014 Sardar Yumatov
+#
+# 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
+import time
+from struct import pack
+
+try:
+    import threading as _threading
+except ImportError:
+    import dummy_threading as _threading
+
+from . import BaseBackend, BaseConnection
+from ..certificate import BaseCertificate
+
+# python 3 support
+import six
+
+# module level logger
+LOG = logging.getLogger(__name__)
+
+
+class Certificate(BaseCertificate):
+    """ Dummy certificate """
+
+    def load_context(self, cert_string=None, cert_file=None, key_string=None, key_file=None, passphrase=None):
+        """ Returns None as we don't handle any context. """
+        return None, None
+
+    def dump_certificate(self, raw_certificate):
+        """ Returns dummy contents. All dummy certificates are equal. """
+        return "CERTIFICATE"
+
+    def dump_digest(self, raw_certificate, digest):
+        """ Returns dummy digsst. All dummy certificates are equal. """
+        return self.dump_certificate(raw_certificate)
+
+
+class Backend(BaseBackend):
+    """ Dummy backend designed for testing without performing real IO. Serves
+        as an exmple for your custom backends.
+    """
+    # simulate stdio behavior
+    can_detect_close = False
+
+    def __init__(self, push=None, feedback=None, **options):
+        """ Create new backend.
+        
+            :Arguments:
+                - push (list): list of status codes to return while sending messages.
+                - feedback (int): number of tokens to generate in the feedback stream.
+        """
+        super(Backend, self).__init__(**options)
+        self.push_results = push
+        self.push_result_pos = -1
+        self.feedback_results = feedback
+        self.new_connections = 0
+        assert (push is not None) ^ (feedback is not None), "Push results or feedback stream must be provided"
+
+    def get_new_connection(self, address, certificate, timeout=None):
+        """ Open a new connection.
+        
+            :Arguments:
+                - address (tuple): target (host, port).
+                - certificate (:class:`Certificate`): certificate instance.
+                - timeout (float): connection timeout in seconds
+        """
+        self.new_connections += 1
+        self.push_result_pos += 1
+        return Connection(self, address, certificate)
+
+    def get_certificate(self, cert_params):
+        """ Create/load certificate from parameters. """
+        return Certificate(**cert_params)
+
+    def create_lock(self):
+        """ Provides semaphore with ``threading.Lock`` interface. """
+        return _threading.Lock()
+
+
+class Connection(BaseConnection):
+    """ Dummy connection. """
+
+    def __init__(self, pool, address, certificate):
+        """ Create new dummy connection.
+        
+            :Arguments:
+                - pool (:class:`Backend`): dummy backend.
+                - address (tuple): target host and port.
+                - certificate (:class:`Certificate`): provider certificate.
+        """
+        super(Connection, self).__init__(address, certificate)
+        self.pool = pool
+        self._closed = False
+
+    def closed(self):
+        """ Returns True if :func:`close` has been explicitly called. """
+        return self._closed
+
+    def close(self):
+        """ Marks this connection as closed. """
+        self._closed = True
+
+    def reset(self):
+        """ Reset dummy connection to use next result record. """
+        pass
+
+    def write(self, data, timeout):
+        """ Does nothing, always succeeds. """
+        if self.closed():
+            raise IOError("Connection closed")
+    
+    def peek(self, size):
+        """ Always returns None as we never fail prematurely. """
+        return None
+
+    def read(self, size, timeout):
+        """ Iterates over preconfigured send/feedback responses. """
+        if self.closed():
+            return None
+
+        if self.pool.push_results is not None:
+            # we are push connection
+            ret = self.pool.push_results[self.pool.push_result_pos % len(self.pool.push_results)]
+            if ret is not None:
+                ret = pack(">BBI", 8, ret, 0)
+
+            return ret
+        else: # feedback mode
+            ret = []
+            for x in range(0, self.pool.feedback_results):
+                token = six.b("test_{}".format(x))
+                ret.append(pack(">IH{}s".format(len(token)), int(time.time()), len(token), token))
+
+            self.close()
+            return six.binary_type().join(ret)

pool/shard000/Python/0007608_wrappers.py

@@ -0,0 +1,168 @@
+from bisect import bisect_left, bisect_right
+
+from numpy import ndarray
+
+from ..conf import settings
+from ..exc import DateNotFound, OutOfBound, RightOutOfBound
+from .section import asarray
+
+
+class TimeSerieWrap:
+
+    def __init__(self, ts, **kwargs):
+        self.ts = ts
+        self.modified = False
+        self.names = ts.names()
+        self.wrap(**kwargs)
+
+    def wrap(self, **kwargs):
+        pass
+
+    def get(self, dt, default = None):
+        '''Equivalent to::
+
+    self[dt]
+
+but catches exceptions and return *default*.'''
+        try:
+            return self[dt]
+        except DateNotFound:
+            return default
+
+    def getts(self):
+        return self.ts
+
+    @property
+    def shape(self):
+        return len(self), self.ts.count()
+
+
+class asbtree(TimeSerieWrap):
+    '''Wrap a :class:`dynts.TimeSeries` and
+expose binary-tree like functionalities. A :class:`dynts.TimeSeries` instance
+has a shortcut method which construct a ``asbtree``. Here is an example::
+
+    >>> from dynts.utils.populate import randomts, date
+    >>> ts = randomts(cols = 2, start = date(2010, 1, 1), size = 50)
+    >>> dts = ts.asbtree()
+    >>> sts.find_ge(ts.start())
+    1
+    >>> sts.find_ge(ts.end())
+    49
+'''
+    def wrap(self):
+        ts = self.ts
+        self.dates  = asarray(ts.dates())
+        self.values = ts.values()
+
+    def __len__(self):
+        return len(self.dates)
+
+    def __getitem__(self, dt):
+        '''Get the value at *dt* otherwise it raises
+an :class:`dynts.exceptions.DateNotFound`.'''
+        try:
+            index = self.find_ge(dt)
+        except OutOfBound:
+            raise DateNotFound
+        if self.dates[index] == dt:
+            return self.values[index]
+        else:
+            raise DateNotFound
+
+    def at(self, dt):
+        val = self[dt]
+        return dict(zip(self.names, val))
+
+    def find_ge(self, dt):
+        '''Building block of all searches. Find the index
+corresponding to the leftmost value greater or equal to *dt*.
+If *dt* is greater than the
+:func:`dynts.TimeSeries.end` a :class:`dynts.exceptions.RightOutOfBound`
+exception will raise.
+
+*dt* must be a python datetime.date instance.'''
+        i = bisect_left(self.dates, dt)
+        if i != len(self.dates):
+            return i
+        raise RightOutOfBound
+
+    def find_le(self, dt):
+        '''Find the index corresponding to the rightmost
+value less than or equal to *dt*.
+If *dt* is less than :func:`dynts.TimeSeries.end`
+a :class:`dynts.exceptions.LeftOutOfBound`
+exception will raise.
+
+*dt* must be a python datetime.date instance.'''
+        i = bisect_right(self.dates, dt)
+        if i:
+            return i-1
+        raise LeftOutOfBound
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.ts.__repr__())
+
+    def __str__(self):
+        return '%s(%s)' % (self.__class__.__name__, self.ts)
+
+
+class ashash(TimeSerieWrap, dict):
+
+    def wrap(self):
+        ts = self.ts
+        hash = {}
+        self.hash = hash
+        dict.__init__(self, ts.items())
+
+    def __getitem__(self, dt):
+        '''Get the value at *dt* otherwise it raises
+an :class:`dynts.exceptions.DateNotFound`.'''
+        try:
+            return dict.__getitem__(self, dt)
+        except KeyError:
+            raise DateNotFound
+
+    def __setitem__(self, dt, item):
+        # if the timeseries contains objects, the items must be a numpy array
+        # otherwise we put it into a 1 element array.
+        if self.ts.is_object and not isinstance(item, ndarray):
+            t, item = item, ndarray((1, ), dtype = self.ts.dtype)
+            item[0] = t
+        dict.__setitem__(self, dt, item)
+        self.modified = True
+
+    def __iter__(self):
+        dates = sorted(dict.__iter__(self))
+        if settings.desc:
+            dates = reversed(dates)
+        return iter(dates)
+
+    def items(self):
+        for dt in self:
+            yield dt, self[dt]
+
+    def getts(self):
+        if self.modified:
+            name = settings.splittingnames.join(self.names)
+            dates = list(self)
+            values = (self[dt] for dt in dates)
+            return self.ts.clone(name = name, date = dates, data = values)
+        else:
+            return self.ts
+
+
+class pair(object):
+    __slots__ = ('time', 'value')
+
+    def __init__(self, time, value):
+        self.time, self.value = time, value
+
+    def __eq__(self, other):
+        return self.time == other.time
+
+    def __gt__(self, other):
+        return self.time > other.time
+
+    def __lt__(self, other):
+        return self.time < other.time

pool/shard000/Python/0007611_widgets.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+from cms.forms.utils import get_site_choices, get_page_choices
+from cms.models import Page, PageUser, Placeholder
+from cms.plugin_pool import plugin_pool
+from cms.utils import get_language_from_request
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.forms.widgets import Select, MultiWidget, Widget
+from django.template.context import RequestContext
+from django.template.loader import render_to_string
+from django.utils.encoding import force_unicode
+from django.utils.safestring import mark_safe
+from django.utils.translation import ugettext as _
+from os.path import join
+import copy
+
+class PageSelectWidget(MultiWidget):
+    """A widget that allows selecting a page by first selecting a site and then
+    a page on that site in a two step process.
+    """
+    def __init__(self, site_choices=None, page_choices=None, attrs=None):
+        if attrs is not None:
+            self.attrs = attrs.copy()
+        else:
+            self.attrs = {}
+        if site_choices is None or page_choices is None:
+            site_choices, page_choices = get_site_choices(), get_page_choices()
+        self.site_choices = site_choices
+        self.choices = page_choices
+        widgets = (Select(choices=site_choices ),
+                   Select(choices=[('', '----')]),
+                   Select(choices=self.choices, attrs={'style': "display:none;"} ),
+        )
+        super(PageSelectWidget, self).__init__(widgets, attrs)
+    
+    def decompress(self, value):
+        """
+        receives a page_id in value and returns the site_id and page_id
+        of that page or the current site_id and None if no page_id is given.
+        """
+        if value:
+            page = Page.objects.get(pk=value)
+            site = page.site
+            return [site.pk, page.pk, page.pk]
+        site = Site.objects.get_current()
+        return [site.pk,None,None]
+    
+    def _has_changed(self, initial, data):
+        # THIS IS A COPY OF django.forms.widgets.Widget._has_changed()
+        # (except for the first if statement)
+        
+        """
+        Return True if data differs from initial.
+        """
+        # For purposes of seeing whether something has changed, None is
+        # the same as an empty string, if the data or inital value we get
+        # is None, replace it w/ u''.
+        if data is None or (len(data)>=2 and data[1] in [None,'']):
+            data_value = u''
+        else:
+            data_value = data
+        if initial is None:
+            initial_value = u''
+        else:
+            initial_value = initial
+        if force_unicode(initial_value) != force_unicode(data_value):
+            return True
+        return False
+    
+    def render(self, name, value, attrs=None):
+        # THIS IS A COPY OF django.forms.widgets.MultiWidget.render()
+        # (except for the last line)
+        
+        # value is a list of values, each corresponding to a widget
+        # in self.widgets.
+        if not isinstance(value, list):
+            value = self.decompress(value)
+        output = []
+        final_attrs = self.build_attrs(attrs)
+        id_ = final_attrs.get('id', None)
+        for i, widget in enumerate(self.widgets):
+            try:
+                widget_value = value[i]
+            except IndexError:
+                widget_value = None
+            if id_:
+                final_attrs = dict(final_attrs, id='%s_%s' % (id_, i))
+            output.append(widget.render(name + '_%s' % i, widget_value, final_attrs))
+        output.append(r'''<script type="text/javascript">
+(function($) {
+    var handleSiteChange = function(site_name, selected_id) {
+        $("#id_%(name)s_1 optgroup").remove();
+        var myOptions = $("#id_%(name)s_2 optgroup[label=" + site_name + "]").clone();
+        $("#id_%(name)s_1").append(myOptions);
+        $("#id_%(name)s_1").change();
+    };
+    var handlePageChange = function(page_id) {
+        if (page_id) {
+            $("#id_%(name)s_2 option").removeAttr('selected');
+            $("#id_%(name)s_2 option[value=" + page_id + "]").attr('selected','selected');
+        } else {
+            $("#id_%(name)s_2 option[value=]").attr('selected','selected');
+        };
+    };
+    $("#id_%(name)s_0").change(function(){
+        var site_label = $("#id_%(name)s_0").children(":selected").text();
+        handleSiteChange( site_label );
+    });
+    $("#id_%(name)s_1").change(function(){
+        var page_id = $(this).find('option:selected').val();
+        handlePageChange( page_id );
+    });
+    $(function(){
+        handleSiteChange( $("#id_%(name)s_0").children(":selected").text() );
+        $("#add_id_%(name)s").hide();
+    });
+})(django.jQuery);
+</script>''' % {'name': name})
+        return mark_safe(self.format_output(output))
+    
+    def format_output(self, rendered_widgets):
+        return u' '.join(rendered_widgets)
+    
+    
+class PluginEditor(Widget):
+    def __init__(self, attrs=None):
+        if attrs is not None:
+            self.attrs = attrs.copy()
+        else:
+            self.attrs = {}
+        
+    class Media:
+        js = [join(settings.CMS_MEDIA_URL, path) for path in (
+            'js/lib/jquery-ui.custom.min.js',
+            'js/plugin_editor.js',
+        )]
+        css = {
+            'all': [join(settings.CMS_MEDIA_URL, path) for path in (
+                'css/plugin_editor.css',
+            )]
+        }
+
+    def render(self, name, value, attrs=None):
+        
+        context = {
+            'plugin_list': self.attrs['list'],
+            'installed_plugins': self.attrs['installed'],
+            'copy_languages': self.attrs['copy_languages'],
+            'language': self.attrs['language'],
+            'show_copy': self.attrs['show_copy'],
+            'placeholder': self.attrs['placeholder'],
+        }
+        return mark_safe(render_to_string(
+            'admin/cms/page/widgets/plugin_editor.html', context))
+
+
+class UserSelectAdminWidget(Select):
+    """Special widget used in page permission inlines, because we have to render
+    an add user (plus) icon, but point it somewhere else - to special user creation
+    view, which is accessible only if user haves "add user" permissions.
+    
+    Current user should be assigned to widget in form constructor as an user 
+    attribute.
+    """
+    def render(self, name, value, attrs=None, choices=()):
+        output = [super(UserSelectAdminWidget, self).render(name, value, attrs, choices)]    
+        if hasattr(self, 'user') and (self.user.is_superuser or \
+            self.user.has_perm(PageUser._meta.app_label + '.' + PageUser._meta.get_add_permission())):
+            # append + icon
+            add_url = '../../../cms/pageuser/add/'
+            output.append(u'<a href="%s" class="add-another" id="add_id_%s" onclick="return showAddAnotherPopup(this);"> ' % \
+                    (add_url, name))
+            output.append(u'<img src="%simg/admin/icon_addlink.gif" width="10" height="10" alt="%s"/></a>' % (settings.ADMIN_MEDIA_PREFIX, _('Add Another')))
+        return mark_safe(u''.join(output))
+    
+    
+class PlaceholderPluginEditorWidget(PluginEditor):
+    attrs = {}
+    def __init__(self, request, filter_func):
+        self.request = request
+        self.filter_func = filter_func
+            
+    def __deepcopy__(self, memo):
+        obj = copy.copy(self)
+        obj.request = copy.copy(self.request)
+        obj.filter_func = self.filter_func
+        memo[id(self)] = obj
+        return obj
+        
+    def render(self, name, value, attrs=None):
+        try:
+            ph = Placeholder.objects.get(pk=value)
+        except Placeholder.DoesNotExist:
+            ph = None
+            context = {'add':True}
+        if ph:
+            plugin_list = ph.cmsplugin_set.filter(parent=None).order_by('position')
+            plugin_list = self.filter_func(self.request, plugin_list)
+            language = get_language_from_request(self.request)
+            copy_languages = []
+            if ph.actions.can_copy:
+                copy_languages = ph.actions.get_copy_languages(
+                    placeholder=ph,
+                    model=ph._get_attached_model(),
+                    fieldname=ph._get_attached_field_name()
+                )
+            context = {
+                'plugin_list': plugin_list,
+                'installed_plugins': plugin_pool.get_all_plugins(ph.slot),
+                'copy_languages': copy_languages, 
+                'language': language,
+                'show_copy': bool(copy_languages) and ph.actions.can_copy,
+                'urloverride': True,
+                'placeholder': ph,
+            }
+        #return mark_safe(render_to_string(
+        #    'admin/cms/page/widgets/plugin_editor.html', context))
+        return mark_safe(render_to_string(
+            'admin/cms/page/widgets/placeholder_editor.html', context, RequestContext(self.request)))

pool/shard000/Python/0007612_protected_entities_radio_astronomy_sites.py

@@ -0,0 +1,107 @@
+from protected_entities import ProtectedEntities
+from protected_entity_radio_astronomy_site import \
+    ProtectedEntityRadioAstronomySite
+import os
+import csv
+import configuration
+
+
+class ProtectedEntitiesRadioAstronomySites(ProtectedEntities):
+    """
+    Intermediate class
+    """
+
+
+class ProtectedEntitiesRadioAstronomySitesUnitedStates(
+    ProtectedEntitiesRadioAstronomySites):
+    """
+    Radioastronomy sites for the United States. Defined in section 15.712(h)
+    of the FCC regulations.
+    """
+
+    def source_filename(self):
+        base_directory = configuration.paths['UnitedStates'][
+            'protected_entities']
+        return os.path.join(base_directory,
+                            "Radioastronomy sites (FCC regulations 2012) - "
+                            "Sheet1.csv")
+
+    def source_name(self):
+        return "FCC 2012 regulations: section 15.712(h)"
+
+    def get_max_protected_radius_km(self):
+        """
+        See
+        :meth:`protected_entities.ProtectedEntities.get_max_protected_radius_km`
+        for more details.
+
+        :return: 10.0
+        :rtype: float
+        """
+        return 10.0
+
+    def _load_entities(self):
+        """Load the protected entities."""
+
+        self.log.debug("Loading radio astronomy sites from \"%s\" (%s)" % (
+        str(self.source_filename()), str(self.source_name())))
+
+        def str2bool(v):
+            return v.lower() in ("yes", "true", "t", "1")
+
+        ras_channel = 37
+
+        with open(self.source_filename(), 'r') as f:
+            ras_csv = csv.DictReader(f)
+            for ras_entry in ras_csv:
+                # print ras_entry
+
+                try:
+                    lat_deg = float(ras_entry['Latitude (degree)'])
+                    lat_min = float(ras_entry['Latitude (minute)'])
+                    lat_sec = float(ras_entry['Latitude (second)'])
+                    lat_dir = ras_entry['Latitude (direction)']
+                    if lat_dir.lower() in ["n", "north"]:
+                        lat_mult = 1.0
+                    else:
+                        lat_mult = -1.0
+                    latitude = lat_mult * (
+                    lat_deg + lat_min / 60 + lat_sec / 3600)
+
+                    lon_deg = float(ras_entry['Longitude (degree)'])
+                    lon_min = float(ras_entry['Longitude (minute)'])
+                    lon_sec = float(ras_entry['Longitude (second)'])
+                    lon_dir = ras_entry['Longitude (direction)']
+                    if lon_dir.lower() in ["e", "east"]:
+                        lon_mult = 1.0
+                    else:
+                        lon_mult = -1.0
+                    longitude = lon_mult * (
+                    lon_deg + lon_min / 60 + lon_sec / 3600)
+
+                    name = ras_entry['Name']
+
+                    is_point = str2bool(ras_entry['Is point'])
+
+                    if is_point:
+                        latitude_deviation = None
+                        longitude_deviation = None
+                    else:
+                        latitude_deviation = float(
+                            ras_entry['Latitude deviation (decimal degrees)'])
+                        longitude_deviation = float(
+                            ras_entry['Longitude deviation (decimal degrees)'])
+
+                    new_ras_entry = ProtectedEntityRadioAstronomySite(
+                        container=self, region=self.get_mutable_region(),
+                        latitude=latitude, longitude=longitude,
+                        channel=ras_channel, name=name, is_point=is_point,
+                        latitude_deviation=latitude_deviation,
+                        longitude_deviation=longitude_deviation)
+
+                    self._add_entity(new_ras_entry)
+
+                except Exception as e:
+                    self.log.error(
+                        "Error reading in radio astronomy sites: " + str(
+                            e) + " (last site read: " + str(name) + ")")

pool/shard000/Python/0007614_pyunit_expr_show.py

@@ -0,0 +1,28 @@
+import sys
+sys.path.insert(1, "../../")
+import h2o, tests
+
+
+def expr_show():
+    
+    
+
+    iris = h2o.import_file(path=tests.locate("smalldata/iris/iris_wheader.csv"))
+    print "iris:"
+    iris.show()
+
+    ###################################################################
+
+    # expr[int], expr._data is pending
+    res = 2 - iris
+    res2 = res[0]
+    print "res2:"
+    res2.show()
+
+    # expr[int], expr._data is remote
+    res3 = res[0]
+    print "res3:"
+    res3.show()
+
+if __name__ == "__main__":
+    tests.run_test(sys.argv, expr_show)

pool/shard000/Python/0007615_nss_http_server.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+
+import json
+from flask import Flask, request, abort, Response
+
+app = Flask(__name__)
+
+
+@app.route('/passwd')
+def passwd():
+    data = [
+        {
+            "pw_name": "testuser1", "pw_passwd": "x", "pw_uid": 6000, "pw_gid": 6000,
+            "pw_gecos": "Testing", "pw_dir": "/home/testuser1", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser2", "pw_passwd": "x", "pw_uid": 6001, "pw_gid": 6000,
+            "pw_gecos": None, "pw_dir": "/home/testuser2", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser3", "pw_passwd": "x", "pw_uid": 6002, "pw_gid": 6001,
+            "pw_gecos": None, "pw_dir": "/home/testuser3", "pw_shell": "/bin/bash",
+        },
+        {
+            "pw_name": "testuser4", "pw_passwd": "x", "pw_uid": 6003, "pw_gid": 6001,
+            "pw_gecos": None, "pw_dir": "/home/testuser4", "pw_shell": "/bin/bash",
+        },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["pw_name"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    uid = request.args.get("uid")
+    if uid:
+        uid = int(uid)
+        for struct in data:
+            if uid == struct["pw_uid"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+@app.route('/group')
+def group():
+    data = [
+        { "gr_name": "testgroup1", "gr_passwd": "x", "gr_gid": 6000, "gr_mem": ["testuser1", "testuser2"], },
+        { "gr_name": "testgroup2", "gr_passwd": "x", "gr_gid": 6001, "gr_mem": ["testuser3", "testuser4"], },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["gr_name"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    gid = request.args.get("gid")
+    if gid:
+        gid = int(gid)
+        for struct in data:
+            if gid == struct["gr_gid"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+@app.route('/shadow')
+def shadow():
+    data = [
+        {
+            "sp_namp": "testuser1", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser2", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser3", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": None, "sp_expire": None, "sp_flag": None,
+        },
+        {
+            "sp_namp": "testuser4", "sp_pwdp": "$1$BXZIu72k$S7oxt9hBiBl/O3Rm3H4Q30", "sp_lstchg": 16034,
+            "sp_min": 0, "sp_max": 99999, "sp_warn": 7, "sp_inact": 10, "sp_expire": 50, "sp_flag": None,
+        },
+    ]
+
+    name = request.args.get("name")
+    if name:
+        for struct in data:
+            if name == struct["sp_namp"]:
+                return Response(json.dumps(struct),  mimetype='application/json')
+        abort(404)
+
+    return Response(json.dumps(data),  mimetype='application/json')
+
+
+if __name__ == "__main__":
+    app.debug = True
+    app.run(host="localhost", port=9669)

pool/shard000/Python/0007617_sms_settings.py

@@ -0,0 +1,108 @@
+# 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 _, throw, msgprint
+from frappe.utils import nowdate
+
+from frappe.model.document import Document
+
+class SMSSettings(Document):
+	pass
+
+def validate_receiver_nos(receiver_list):
+	validated_receiver_list = []
+	for d in receiver_list:
+		# remove invalid character
+		for x in [' ', '+', '-', '(', ')']:
+			d = d.replace(x, '')
+
+		validated_receiver_list.append(d)
+
+	if not validated_receiver_list:
+		throw(_("Please enter valid mobile nos"))
+
+	return validated_receiver_list
+
+
+def get_sender_name():
+	"returns name as SMS sender"
+	sender_name = frappe.db.get_single_value('SMS Settings', 'sms_sender_name') or \
+		'ERPNXT'
+	if len(sender_name) > 6 and \
+			frappe.db.get_default("country") == "India":
+		throw("""As per TRAI rule, sender name must be exactly 6 characters.
+			Kindly change sender name in Setup --> Global Defaults.
+			Note: Hyphen, space, numeric digit, special characters are not allowed.""")
+	return sender_name
+
+@frappe.whitelist()
+def get_contact_number(contact_name, value, key):
+	"returns mobile number of the contact"
+	number = frappe.db.sql("""select mobile_no, phone from tabContact where name=%s and %s=%s""" %
+		('%s', frappe.db.escape(key), '%s'), (contact_name, value))
+	return number and (number[0][0] or number[0][1]) or ''
+
+@frappe.whitelist()
+def send_sms(receiver_list, msg, sender_name = ''):
+
+	import json
+	if isinstance(receiver_list, basestring):
+		receiver_list = json.loads(receiver_list)
+		if not isinstance(receiver_list, list):
+			receiver_list = [receiver_list]
+
+	receiver_list = validate_receiver_nos(receiver_list)
+
+	arg = {
+		'receiver_list' : receiver_list,
+		'message'		: msg,
+		'sender_name'	: sender_name or get_sender_name()
+	}
+
+	if frappe.db.get_value('SMS Settings', None, 'sms_gateway_url'):
+		send_via_gateway(arg)
+	else:
+		msgprint(_("Please Update SMS Settings"))
+
+def send_via_gateway(arg):
+	ss = frappe.get_doc('SMS Settings', 'SMS Settings')
+	args = {ss.message_parameter: arg.get('message')}
+	for d in ss.get("parameters"):
+		args[d.parameter] = d.value
+
+	success_list = []
+	for d in arg.get('receiver_list'):
+		args[ss.receiver_parameter] = d
+		status = send_request(ss.sms_gateway_url, args)
+		if status >= 200 and status < 300:
+			success_list.append(d)
+
+	if len(success_list) > 0:
+		args.update(arg)
+		create_sms_log(args, success_list)
+		frappe.msgprint(_("SMS sent to following numbers: {0}").format("\n" + "\n".join(success_list)))
+
+
+def send_request(gateway_url, params):
+	import requests
+	response = requests.get(gateway_url, params = params, headers={'Accept': "text/plain, text/html, */*"})
+	response.raise_for_status()
+	return response.status_code
+
+
+# Create SMS Log
+# =========================================================
+def create_sms_log(args, sent_to):
+	sl = frappe.new_doc('SMS Log')
+	sl.sender_name = args['sender_name']
+	sl.sent_on = nowdate()
+	sl.message = args['message']
+	sl.no_of_requested_sms = len(args['receiver_list'])
+	sl.requested_numbers = "\n".join(args['receiver_list'])
+	sl.no_of_sent_sms = len(sent_to)
+	sl.sent_to = "\n".join(sent_to)
+	sl.flags.ignore_permissions = True
+	sl.save()

pool/shard000/Python/0007618_setup.py

@@ -0,0 +1,101 @@
+import platform
+import sys
+import os
+
+from setuptools import find_packages, setup
+
+
+def findRequirements():
+  """
+  Read the requirements.txt file and parse into requirements for setup's
+  install_requirements option.
+  """
+  return [
+    line.strip()
+    for line in open("requirements.txt").readlines()
+    if not line.startswith("#")
+    ]
+
+
+
+depLinks = []
+
+
+
+# If we wanted to use nupic
+# if "linux" in sys.platform and platform.linux_distribution()[0] == "CentOS":
+#  depLinks = [ "https://pypi.numenta.com/pypi/nupic",
+#               "https://pypi.numenta.com/pypi/nupic.bindings" ]
+
+
+def read(fname):
+  """
+  Utility function to read specified file.
+  """
+  path = os.path.join(os.path.dirname(__file__), fname)
+  return open(path).read()
+
+
+
+setup(name="cloudbrain",
+      version="0.2.1",
+      description="Platform for wearable data analytics.",
+      author="Marion Le Borgne",
+      url="https://github.com/marionleborgne/cloudbrain",
+      packages=find_packages(),
+      install_requires=findRequirements(),
+      include_package_data=True,
+      dependency_links=depLinks,
+      long_description=read("README.md"),
+      license='GNU Affero General Public License v3',
+      classifiers=[
+        'License :: OSI Approved :: GNU Affero General Public License v3'
+      ],
+      entry_points={
+        'console_scripts': [
+          'cloudbrain = cloudbrain.run:main'
+        ]
+      })
+
+
+# import os
+# from setuptools import setup, find_packages
+# from pip.req import parse_requirements
+# 
+# 
+# 
+# # parse_requirements() returns generator of pip.req.InstallRequirement objects
+# install_reqs = parse_requirements("requirements.txt")
+# 
+# # reqs is a list of requirement
+# # e.g. ['django==1.5.1', 'mezzanine==1.4.6']
+# reqs = [str(ir.req) for ir in install_reqs]
+# 
+# 
+# 
+# def read(fname):
+#   """
+#   Utility function to read specified file.
+#   """
+#   path = os.path.join(os.path.dirname(__file__), fname)
+#   return open(path).read()
+# 
+# 
+# 
+# setup(name="cloudbrain",
+#       version="0.2.1",
+#       description=("Platform for real-time sensor data analysis and 
+#                     visualization."),
+#       packages=find_packages(),
+#       install_requires=reqs,
+#       include_package_data=True,
+#       long_description=read("README.md"),
+#       license='GNU Affero General Public License v3',
+#       classifiers=[
+#           'License :: OSI Approved :: GNU Affero General Public License v3'
+#       ],
+#       entry_points = {
+#         'console_scripts': [
+#             'cloudbrain = cloudbrain.run:main'
+#         ]
+#       })

pool/shard000/Python/0007619_test_events.py

@@ -0,0 +1,113 @@
+from __future__ import absolute_import, unicode_literals
+
+import unittest
+
+import mock
+
+import pykka
+
+from mopidy import core
+from mopidy.internal import deprecation
+from mopidy.models import Track
+
+from tests import dummy_backend
+
+
+@mock.patch.object(core.CoreListener, 'send')
+class BackendEventsTest(unittest.TestCase):
+
+    def setUp(self):  # noqa: N802
+        config = {
+            'core': {
+                'max_tracklist_length': 10000,
+            }
+        }
+
+        self.backend = dummy_backend.create_proxy()
+        self.backend.library.dummy_library = [
+            Track(uri='dummy:a'), Track(uri='dummy:b')]
+
+        with deprecation.ignore():
+            self.core = core.Core.start(
+                config, backends=[self.backend]).proxy()
+
+    def tearDown(self):  # noqa: N802
+        pykka.ActorRegistry.stop_all()
+
+    def test_forwards_backend_playlists_loaded_event_to_frontends(self, send):
+        self.core.playlists_loaded().get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_forwards_mixer_volume_changed_event_to_frontends(self, send):
+        self.core.volume_changed(volume=60).get()
+
+        self.assertEqual(send.call_args[0][0], 'volume_changed')
+        self.assertEqual(send.call_args[1]['volume'], 60)
+
+    def test_forwards_mixer_mute_changed_event_to_frontends(self, send):
+        self.core.mute_changed(mute=True).get()
+
+        self.assertEqual(send.call_args[0][0], 'mute_changed')
+        self.assertEqual(send.call_args[1]['mute'], True)
+
+    def test_tracklist_add_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_clear_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.core.tracklist.clear().get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_move_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a', 'dummy:b']).get()
+
+        self.core.tracklist.move(0, 1, 1).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_remove_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a']).get()
+
+        self.core.tracklist.remove({'uri': ['dummy:a']}).get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_tracklist_shuffle_sends_tracklist_changed_event(self, send):
+        self.core.tracklist.add(uris=['dummy:a', 'dummy:b']).get()
+
+        self.core.tracklist.shuffle().get()
+
+        self.assertEqual(send.call_args[0][0], 'tracklist_changed')
+
+    def test_playlists_refresh_sends_playlists_loaded_event(self, send):
+        self.core.playlists.refresh().get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_playlists_refresh_uri_sends_playlists_loaded_event(self, send):
+        self.core.playlists.refresh(uri_scheme='dummy').get()
+
+        self.assertEqual(send.call_args[0][0], 'playlists_loaded')
+
+    def test_playlists_create_sends_playlist_changed_event(self, send):
+        self.core.playlists.create('foo').get()
+
+        self.assertEqual(send.call_args[0][0], 'playlist_changed')
+
+    @unittest.SkipTest
+    def test_playlists_delete_sends_playlist_deleted_event(self, send):
+        # TODO We should probably add a playlist_deleted event
+        pass
+
+    def test_playlists_save_sends_playlist_changed_event(self, send):
+        playlist = self.core.playlists.create('foo').get()
+        playlist = playlist.replace(name='bar')
+
+        self.core.playlists.save(playlist).get()
+
+        self.assertEqual(send.call_args[0][0], 'playlist_changed')

pool/shard000/Python/0007621_ScreenBlocksTest.py

@@ -0,0 +1,48 @@
+from yandextank.plugins.ConsoleScreen import Screen, CurrentHTTPBlock, CurrentNetBlock
+from ConsoleOnlinePluginTest import FakeConsoleMarkup
+from TankTests import TankTestCase
+
+class BlocksTestCase(TankTestCase):
+    def test_HTTP(self):
+        screen = Screen(50, FakeConsoleMarkup())
+        block = CurrentHTTPBlock(screen)
+        block.render()
+        print block.lines
+        self.assertEquals('<w>HTTP for 0 RPS:  <rst>', block.lines[0].strip())
+        self.assertEquals(1, len(block.lines))
+    
+        data = self.get_aggregate_data('data/preproc_single.txt')
+        data.overall.planned_requests = 100
+        data.overall.http_codes = {'400': 10}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(2, len(block.lines))
+
+        data.overall.http_codes = {'200': 4}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(3, len(block.lines))
+
+    def test_Net(self):
+        screen = Screen(50, FakeConsoleMarkup())
+        block = CurrentNetBlock(screen)
+        block.render()
+        print block.lines
+        self.assertEquals('<w> NET for 0 RPS:  <rst>', block.lines[0].strip())
+        self.assertEquals(1, len(block.lines))
+    
+        data = self.get_aggregate_data('data/preproc_single.txt')
+        data.overall.planned_requests = 100
+        data.overall.net_codes = {'0': 10}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(2, len(block.lines))
+
+        data.overall.net_codes = {'71': 4}
+        block.add_second(data)
+        block.render()
+        print block.lines
+        self.assertEquals(3, len(block.lines))

pool/shard000/Python/0007623_first.py

@@ -0,0 +1,25 @@
+#!/usr/bin/python
+
+balance = 0
+
+def deposit(amount):
+	global balance
+	balance = balance + amount
+	return balance
+
+def withdraw(amount):
+	global balance
+	balance = balance - amount
+	return balance
+
+# Ranjith
+print "my initial balance {}".format(balance)
+print " i am depositing 1000 rs to Ranjith"
+deposit(1000)
+print "my  balance after deposti{}".format(balance)
+print " i am with drawing 500 rs of Ranjith"
+withdraw(500)
+print "my balance {} after withdraw".format(balance)
+
+# Raj
+print "my initial balance {}".format(balance)

pool/shard000/Python/0007624_get_redirected_url.py

@@ -0,0 +1,55 @@
+"""
+Copyright (c) 2016, Marcelo Leal
+Description: Simple Azure Media Services Python library
+License: MIT (see LICENSE.txt file for details)
+"""
+import os
+import json
+import azurerm
+import time
+#import pytz
+import logging
+import datetime
+
+###########################################################################################
+##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER #####
+###########################################################################################
+
+# ALL CODE IN THIS DIRECTOY (INCLUDING THIS FILE) ARE EXAMPLE CODES THAT  WILL  ACT ON YOUR
+# AMS ACCOUNT.  IT ASSUMES THAT THE AMS ACCOUNT IS CLEAN (e.g.: BRAND NEW), WITH NO DATA OR
+# PRODUCTION CODE ON IT.  DO NOT, AGAIN: DO NOT RUN ANY EXAMPLE CODE AGAINST PRODUCTION AMS
+# ACCOUNT!  IF YOU RUN ANY EXAMPLE CODE AGAINST YOUR PRODUCTION  AMS ACCOUNT,  YOU CAN LOSE
+# DATA, AND/OR PUT YOUR AMS SERVICES IN A DEGRADED OR UNAVAILABLE STATE. BE WARNED!
+
+###########################################################################################
+##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER ##### ##### DISCLAIMER #####
+###########################################################################################
+
+# Load Azure app defaults
+try:
+	with open('config.json') as configFile:
+		configData = json.load(configFile)
+except FileNotFoundError:
+	print("ERROR: Expecting config.json in current folder")
+	sys.exit()
+
+account_name = configData['accountName']
+account_key = configData['accountKey']
+
+# Get the access token...
+response = azurerm.get_ams_access_token(account_name, account_key)
+resjson = response.json()
+access_token = resjson["access_token"]
+
+#Initialization...
+print ("\n-----------------------= AMS Py =----------------------");
+print ("Simple Python Library for Azure Media Services REST API");
+print ("-------------------------------------------------------\n");
+
+### get ams redirected url
+response = azurerm.get_url(access_token)
+if (response.status_code == 200):
+	print("New Redirected URL: " + str(response.url))
+else:
+	print("GET Status: " + str(response.status_code) + " - Getting Redirected URL ERROR." + str(response.content))
+

pool/shard000/Python/0007625_pyminer.py

@@ -0,0 +1,252 @@
+#!/usr/bin/python
+#
+# Copyright (c) 2011 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 time
+import json
+import pprint
+import hashlib
+import struct
+import re
+import base64
+import httplib
+import sys
+from multiprocessing import Process
+
+ERR_SLEEP = 15
+MAX_NONCE = 1000000L
+
+settings = {}
+pp = pprint.PrettyPrinter(indent=4)
+
+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 getblockcount(self):
+		return self.rpc('getblockcount')
+	def getwork(self, data=None):
+		return self.rpc('getwork', data)
+
+def uint32(x):
+	return x & 0xffffffffL
+
+def bytereverse(x):
+	return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) |
+			(((x) >> 8) & 0x0000ff00) | ((x) >> 24) ))
+
+def bufreverse(in_buf):
+	out_words = []
+	for i in range(0, len(in_buf), 4):
+		word = struct.unpack('@I', in_buf[i:i+4])[0]
+		out_words.append(struct.pack('@I', bytereverse(word)))
+	return ''.join(out_words)
+
+def wordreverse(in_buf):
+	out_words = []
+	for i in range(0, len(in_buf), 4):
+		out_words.append(in_buf[i:i+4])
+	out_words.reverse()
+	return ''.join(out_words)
+
+class Miner:
+	def __init__(self, id):
+		self.id = id
+		self.max_nonce = MAX_NONCE
+
+	def work(self, datastr, targetstr):
+		# decode work data hex string to binary
+		static_data = datastr.decode('hex')
+		static_data = bufreverse(static_data)
+
+		# the first 76b of 80b do not change
+		blk_hdr = static_data[:76]
+
+		# decode 256-bit target value
+		targetbin = targetstr.decode('hex')
+		targetbin = targetbin[::-1]	# byte-swap and dword-swap
+		targetbin_str = targetbin.encode('hex')
+		target = long(targetbin_str, 16)
+
+		# pre-hash first 76b of block header
+		static_hash = hashlib.sha256()
+		static_hash.update(blk_hdr)
+
+		for nonce in xrange(self.max_nonce):
+
+			# encode 32-bit nonce value
+			nonce_bin = struct.pack("<I", nonce)
+
+			# hash final 4b, the nonce value
+			hash1_o = static_hash.copy()
+			hash1_o.update(nonce_bin)
+			hash1 = hash1_o.digest()
+
+			# sha256 hash of sha256 hash
+			hash_o = hashlib.sha256()
+			hash_o.update(hash1)
+			hash = hash_o.digest()
+
+			# quick test for winning solution: high 32 bits zero?
+			if hash[-4:] != '\0\0\0\0':
+				continue
+
+			# convert binary hash to 256-bit Python long
+			hash = bufreverse(hash)
+			hash = wordreverse(hash)
+
+			hash_str = hash.encode('hex')
+			l = long(hash_str, 16)
+
+			# proof-of-work test:  hash < target
+			if l < target:
+				print time.asctime(), "PROOF-OF-WORK found: %064x" % (l,)
+				return (nonce + 1, nonce_bin)
+			else:
+				print time.asctime(), "PROOF-OF-WORK false positive %064x" % (l,)
+#				return (nonce + 1, nonce_bin)
+
+		return (nonce + 1, None)
+
+	def submit_work(self, rpc, original_data, nonce_bin):
+		nonce_bin = bufreverse(nonce_bin)
+		nonce = nonce_bin.encode('hex')
+		solution = original_data[:152] + nonce + original_data[160:256]
+		param_arr = [ solution ]
+		result = rpc.getwork(param_arr)
+		print time.asctime(), "--> Upstream RPC result:", result
+
+	def iterate(self, rpc):
+		work = rpc.getwork()
+		if work is None:
+			time.sleep(ERR_SLEEP)
+			return
+		if 'data' not in work or 'target' not in work:
+			time.sleep(ERR_SLEEP)
+			return
+
+		time_start = time.time()
+
+		(hashes_done, nonce_bin) = self.work(work['data'],
+						     work['target'])
+
+		time_end = time.time()
+		time_diff = time_end - time_start
+
+		self.max_nonce = long(
+			(hashes_done * settings['scantime']) / time_diff)
+		if self.max_nonce > 0xfffffffaL:
+			self.max_nonce = 0xfffffffaL
+
+		if settings['hashmeter']:
+			print "HashMeter(%d): %d hashes, %.2f Khash/sec" % (
+			      self.id, hashes_done,
+			      (hashes_done / 1000.0) / time_diff)
+
+		if nonce_bin is not None:
+			self.submit_work(rpc, work['data'], nonce_bin)
+
+	def loop(self):
+		rpc = BitcoinRPC(settings['host'], settings['port'],
+				 settings['rpcuser'], settings['rpcpass'])
+		if rpc is None:
+			return
+
+		while True:
+			self.iterate(rpc)
+
+def miner_thread(id):
+	miner = Miner(id)
+	miner.loop()
+
+if __name__ == '__main__':
+	if len(sys.argv) != 2:
+		print "Usage: pyminer.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 'host' not in settings:
+		settings['host'] = '127.0.0.1'
+	if 'port' not in settings:
+		settings['port'] = 4869
+	if 'threads' not in settings:
+		settings['threads'] = 1
+	if 'hashmeter' not in settings:
+		settings['hashmeter'] = 0
+	if 'scantime' not in settings:
+		settings['scantime'] = 30L
+	if 'rpcuser' not in settings or 'rpcpass' not in settings:
+		print "Missing username and/or password in cfg file"
+		sys.exit(1)
+
+	settings['port'] = int(settings['port'])
+	settings['threads'] = int(settings['threads'])
+	settings['hashmeter'] = int(settings['hashmeter'])
+	settings['scantime'] = long(settings['scantime'])
+
+	thr_list = []
+	for thr_id in range(settings['threads']):
+		p = Process(target=miner_thread, args=(thr_id,))
+		p.start()
+		thr_list.append(p)
+		time.sleep(1)			# stagger threads
+
+	print settings['threads'], "mining threads started"
+
+	print time.asctime(), "Miner Starts - %s:%s" % (settings['host'], settings['port'])
+	try:
+		for thr_proc in thr_list:
+			thr_proc.join()
+	except KeyboardInterrupt:
+		pass
+	print time.asctime(), "Miner Stops - %s:%s" % (settings['host'], settings['port'])
+

pool/shard000/Python/0007628_config.py

@@ -0,0 +1,55 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2012, Nachi Ueno, NTT MCL, 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 oslo.config import cfg
+
+
+meta_plugin_opts = [
+    cfg.StrOpt('plugin_list', default='',
+               help=_("List of plugins to load")),
+    cfg.StrOpt('l3_plugin_list', default='',
+               help=_("List of L3 plugins to load")),
+    cfg.StrOpt('default_flavor', default='',
+               help=_("Default flavor to use")),
+    cfg.StrOpt('default_l3_flavor', default='',
+               help=_("Default L3 flavor to use")),
+    cfg.StrOpt('supported_extension_aliases', default='',
+               help=_("Supported extension aliases")),
+    cfg.StrOpt('extension_map', default='',
+               help=_("A list of extensions, per plugin, to load.")),
+    cfg.StrOpt('rpc_flavor', default='',
+               help=_("Flavor of which plugin handles RPC")),
+]
+
+proxy_plugin_opts = [
+    cfg.StrOpt('admin_user',
+               help=_("Admin user")),
+    cfg.StrOpt('admin_password',
+               help=_("Admin password"),
+               secret=True),
+    cfg.StrOpt('admin_tenant_name',
+               help=_("Admin tenant name")),
+    cfg.StrOpt('auth_url',
+               help=_("Authentication URL")),
+    cfg.StrOpt('auth_strategy', default='keystone',
+               help=_("The type of authentication to use")),
+    cfg.StrOpt('auth_region',
+               help=_("Authentication region")),
+]
+
+cfg.CONF.register_opts(meta_plugin_opts, "META")
+cfg.CONF.register_opts(proxy_plugin_opts, "PROXY")

pool/shard000/Python/0007631_bluedump.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# file: inquiry.py
+# auth: Albert Huang <albert@csail.mit.edu>
+# desc: performs a simple device inquiry followed by a remote name request of
+#       each discovered device
+# $Id: inquiry.py 401 2006-05-05 19:07:48Z albert $
+#
+
+import bluetooth
+import sqlite3
+import sys
+from pprint import pprint,pformat
+
+print "Setup database connection"
+conn = sqlite3.connect('bluematter.db')
+print "Opened database successfully";
+
+print "Check if table 'people' exists."
+cursor=conn.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='people';")
+tableFound=False
+for row in cursor:
+  if row[0] == 'people':
+    tableFound=True
+    print "Table 'people' already exists. Good."
+    break
+
+#
+if tableFound == False:
+  print "Table 'people' was not found. Exiting."
+  sys.exit(1)
+
+cursor=conn.execute("select * from people ")
+data=cursor.fetchall()
+if len(data)==0:
+  print("There is no data in table 'people'.")
+else:
+  pprint(data)
+
+conn.close()

pool/shard000/Python/0007632_getpathart.py

@@ -0,0 +1,120 @@
+#!/usr/bin/python3
+
+import os
+import cgi
+import json
+import subprocess
+import sqlite3 as lite
+
+class GetPathArt():
+	def __init__(self):
+		db_loc      = "/usr/share/ampyche/db/ampyche.db"
+		self.db_loc = db_loc
+		settings_db = "/usr/share/ampyche/db/settings.db"
+		self.settings_db = settings_db
+
+	def _get_webpath(self):
+		wlan0 = subprocess.getoutput('/sbin/ifconfig wlan0')
+		error = "wlan0: error fetching interface information: Device not found"
+		if wlan0 == error:
+			ipa = subprocess.getoutput('/sbin/ifconfig').split('\n')[1].split()[1][5:]
+			return ipa
+		else:
+			ipa = subprocess.getoutput('/sbin/ifconfig').split('\n')[17].split()[1][5:]
+			return ipa
+
+	def _create_path(self, fn):
+		con = lite.connect(self.settings_db)
+		cur = con.cursor()
+		cur.execute("SELECT catname, hostaddress FROM settings")
+		q = cur.fetchall()
+		con.close()
+		boo = "/usr/share/ampyche/music/" + q[0][0]
+		base = q[0][1] + "/music/" + q[0][0]
+		fn = fn[len(boo):]
+		fn = base + fn
+		fntmp = q[0][1] + "/music/tmp/" + fn[35:]
+		fsfntmp = "/usr/share/ampyche/music/tmp/" + fn[35:]
+		return fn, fntmp, fsfntmp
+		
+	def _get_path_pic_for_song(self, sname, cpogg, cpmp3):
+		con = lite.connect(self.db_loc)
+		cur = con.cursor()
+		cur.execute("SELECT filename, album_art, fileid, song FROM ampyche WHERE song=?", [sname])
+		song = cur.fetchall()
+		gg = []
+		for s in song:
+			fn = s[0]
+			fnl = fn.lower()
+			ext = fnl[-3:]
+			y = {}
+			y['songname'] = s[3]
+			albumart = s[1]
+			albumart = albumart[10:]
+			z = self._get_webpath()
+			z = "http://" + z
+			albumart1 = z + albumart
+			y['albumart'] = albumart1
+			y['fileid'] = s[2]
+			if ext == "mp3":
+				#Browser supports mp3 playback so play the song
+				if cpmp3 == "true" and cpogg == 'true':
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == "true" and cpogg == 'false':
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == "false" and cpogg == 'true':
+					filename = self._create_path(fn)
+					filename1 = filename[1]
+					webpath = filename1[:-3] + "ogg"
+					convpath = filename[2][:-3] + "ogg"
+					dirmp3 = os.path.dirname(filename[2])
+					if not os.path.exists(dirmp3):
+						os.makedirs(dirmp3)
+					subprocess.call(['avconv', '-i', fn, '-ab', '128k', '-acodec', 'libvorbis', convpath])
+					y['filename'] = webpath
+					gg.append(y)
+				else:
+					pass
+			elif ext == "ogg":
+				if cpmp3 == 'true' and cpogg == "true":
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == 'false' and cpogg == "true":
+					filename = self._create_path(fn)
+					y['filename'] = filename[0]
+					gg.append(y)
+				elif cpmp3 == 'true' and cpogg == "false":
+					filename = self._create_path(fn)
+					filename = filename[1]
+					filenamemp3 = filename[:-3] + "mp3"
+					dirogg = os.path.dirname(filename[2])
+					if not os.path.exists(dirogg):
+						os.makedirs(dirogg)
+					#subprocess.call(['avconv', '-i', fn, '-ab', '128k', filenamemp3])
+					y['filename'] = filenamemp3
+					gg.append(y)
+				else:
+					pass
+			else:
+				pass
+		print(json.dumps(gg, sort_keys=True, indent=4))
+				
+	
+print("Content-Type: application/json\n\n")
+s = cgi.FieldStorage()
+
+#sn = "Brown Eyes"
+#fsogg = "true"
+#fsmp3 = "false"
+
+
+sn = s.getvalue("songname")
+fsogg = s.getvalue('canplayogg')
+fsmp3 = s.getvalue('canplaymp3')
+GPA = GetPathArt()
+run = GPA._get_path_pic_for_song(sn, fsogg, fsmp3)

pool/shard000/Python/0007635_update_collection.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+#Last-modified: 14 Jan 2013 02:04:05 PM
+import json
+import os.path
+import hashlib
+
+
+HASH_PREFIX = "/mnt/us/documents/"
+ALLOWED_EXTENSIONS = ["pdf", "mobi", "azw", "txt", "prc"]
+
+class Collection(object):
+    def __init__(self, root="/media/Kindle/"):
+        """ Initialize the Collection class, load the existing class.
+        """
+        self.root = root
+        # load the current collections
+        self.load()
+
+    def load(self):
+        """ load existing collection json file.
+        """
+        fcln = os.path.join(self.root, "system", "collections.json")
+        f    = file(fcln, "r")
+        # json file
+        self.cln = json.load(f)
+        # all the collection names
+        self.cnames = self.cln.keys()
+        f.close()
+
+    def update(self, c, new_hal, fname):
+        """ update collection and new_hal to the database.
+        """
+        _c = " ".join([c, "-@en-US"]) 
+        if _c in self.cnames :
+            if new_hal in self.cln[_c]["items"] or "*"+new_hal in self.cln[_c]["items"] :
+                pass
+            else :
+                print("file %s does not exist in %s..."%(fname, _c))
+                print("append file %s to %s..."%(fname, _c))
+                self.cln[_c]["items"].append("*%s" % new_hal)
+        else :
+            print("collection %s does not exist, create..."%_c)
+            print("append file %s to %s..."%(fname, _c))
+            new_collection = {"items":[]}
+            new_collection["items"].append("*%s" % new_hal)
+            self.cln[_c] = new_collection
+            self.cnames  = self.cln.keys()
+
+    def forage(self, folder="Incoming"):
+        """ detect new files and merge them into data base.
+        """
+        if folder.startswith("/") :
+            raise RuntimeError("folder needs to be a dir relative to <documents>")
+        elif len(folder) == 0 :
+            isnode = True
+            path = os.path.join(self.root, "documents")
+        else :
+            isnode = False
+            path = os.path.join(self.root, "documents", folder)
+        if not os.path.isdir(path) :
+            print("folder %s does not exist, exit..." % folder)
+        else  :
+            print("foraging directory : %s" % folder)
+        if isnode :
+            current_collection = None
+            print("at root node")
+        else :
+            current_collection = folder.replace("/", " - ")
+            print("Current collection name : %s" % current_collection)
+        # Go through all the files in this directory
+        for filename in os.listdir(path):
+            # Check if is a file
+            if os.path.isfile(os.path.join(path, filename)) and (not isnode):
+                # Get extension of that file
+                extension = filename.split(".")[-1]
+                # Check if file is the one we would want to add
+                if extension in ALLOWED_EXTENSIONS :
+                    # Calculate SHA1 hash for the /mnt/us/<folder>/<filename>
+                    old_hal = gethash(os.path.join(folder, filename))
+                    self.update(current_collection, old_hal, filename)
+            # Check if is directory
+            elif os.path.isdir(os.path.join(path, filename)):
+                    # Parse this sub-directory recursively
+                    self.forage(folder=os.path.join(folder, filename))
+
+    def save(self, outdir=None) :
+        """ Convert collections to JSON
+        """
+        collections_json = json.dumps(self.cln)
+        # Write JSON to a collections.json
+        if outdir is None :
+            json_path = os.path.join(self.root, "system", "collections.json")
+        else :
+            json_path = outdir
+        print("Writing collections.json file to %s" % json_path)
+        f = open(json_path, "w")
+        f.write(collections_json)
+        f.close()
+
+    def default(self) :
+        self.cln    = {}
+        self.cnames = []
+        self.forage(folder="")
+
+def gethash(fname):
+    """ get hash string.
+    """
+    hin = os.path.join(HASH_PREFIX, fname)
+    hobj = hashlib.sha1(hin)
+    hval = hobj.hexdigest()
+    return(hval)
+
+if __name__ == "__main__":    
+    cln = Collection()
+    cln.forage(folder="Incoming/arxiv")
+#    cln.default()
+    cln.save()

pool/shard000/Python/0007640_get_completions_test.py

@@ -0,0 +1,45 @@
+# Copyright (C) 2015 ycmd contributors
+#
+# This file is part of ycmd.
+#
+# ycmd 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.
+#
+# ycmd 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 ycmd.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import division
+from future import standard_library
+standard_library.install_aliases()
+from builtins import *  # noqa
+
+from hamcrest import assert_that, has_item
+from .go_handlers_test import Go_Handlers_test
+from ycmd.utils import ReadFile
+
+
+class Go_GetCompletions_test( Go_Handlers_test ):
+
+  def Basic_test( self ):
+    filepath = self._PathToTestFile( 'test.go' )
+    completion_data = self._BuildRequest( filepath = filepath,
+                                          filetype = 'go',
+                                          contents = ReadFile( filepath ),
+                                          force_semantic = True,
+                                          line_num = 9,
+                                          column_num = 11 )
+
+    results = self._app.post_json( '/completions',
+                                   completion_data ).json[ 'completions' ]
+    assert_that( results,
+                 has_item( self._CompletionEntryMatcher( u'Logger' ) ) )

pool/shard000/Python/0007644_test_model_serializer_deserialize_fk.py

@@ -0,0 +1,66 @@
+from ..serializers.model_serializer import ModelSerializer
+from .dragon_test_case import DragonTestCase
+from .models import TextModel, SDModel
+from django.db import models
+
+
+class Parent(SDModel):
+    name = models.CharField(max_length=20)
+
+
+class Child(SDModel):
+    parent = models.ForeignKey(Parent)
+    number = models.IntegerField()
+
+
+class ChildSerializer(ModelSerializer):
+    parent = 'ParentSerializer'
+
+    class Meta:
+        model = Child
+        update_fields = ('number', 'parent')
+
+
+class ParentSerializer(ModelSerializer):
+    child_set = ChildSerializer
+
+    class Meta:
+        model = Parent
+        publish_fields = ('name')
+        update_fields = ('name', 'child_set')
+
+
+class TestModelSerializer(DragonTestCase):
+    def test_deserialize_with_fk(self):
+        data = {
+            'name': 'foo',
+            'child_set': [
+                {'number': 5}
+            ]
+        }
+        serializer = ParentSerializer(data)
+        parent = serializer.save()
+        self.assertEqual(parent.name, data['name'])
+        self.assertEqual(parent.child_set.first().number, data['child_set'][0]['number'])
+
+    def test_deserialize_with_reverse_fk(self):
+        data = {
+            'number': 123,
+            'parent': {
+                'name': 'foo'
+            }
+        }
+        serializer = ChildSerializer(data)
+        child = serializer.save()
+        self.assertEqual(child.number, data['number'])
+        self.assertEqual(child.parent.name, data['parent']['name'])
+
+    def test_get_object_map(self):
+        """
+        The object map should return information on how to map parents to children
+        and vice versa
+        """
+        object_map = ParentSerializer.get_object_map()
+        self.assertLessEqual(len(object_map), 2)
+        for om in object_map:
+            self.assertIn('via', om)

pool/shard000/Python/0007647_INIFILE.py

@@ -0,0 +1,76 @@
+# -*- coding:utf-8 -*_
+import ConfigParser, sys
+class INIFILE:
+    """
+    a class which can process *.ini file
+    with read and write function.
+    """
+    def __init__(self, fileName):
+        self.fileName = fileName
+        # print self.fileName
+        self.initflag = False
+        self.cfg = None
+        self.readhandle = None
+        self.writehandle = None
+        self.is_read = False
+        self.is_write = False
+
+    #is_read :is read enable? is_write: is write enable?
+    #must write something if you set is_write to true. otherwise your file become empty.
+    def Init(self, is_read, is_write):
+        self.cfg = ConfigParser.ConfigParser()
+        try:
+            if is_read:
+                self.is_read = True
+                self.readhandle = open(self.fileName, 'r')
+                self.cfg.readfp(self.readhandle)
+
+            if  is_write:
+                self.is_write = True
+                self.writehandle =  open(self.fileName, 'w')
+
+            self.initflag = True
+        except Exception, e:
+            self.initflag = False
+            print e
+        return self.initflag
+
+    #close the file
+    def UnInit(self):
+        if self.initflag:
+            if self.is_read:
+                self.readhandle.close()
+                #print '================close the read handle================'
+            if self.is_write:
+                self.writehandle.close()
+                #print '================close the write handle================'
+
+    def GetValue(self, Section, Key, Default = '0'):
+        try:
+            value = self.cfg.get(Section, Key)
+        except Exception, e:
+            #print e
+            value = Default
+        return value
+
+    def SetValue(self, Section, Key, Value):
+        if not self.is_write:
+            print 'can not SetValue, switch the write function to true first.'
+            return
+        if not self.cfg.has_section(Section):
+            print 'Section [%s] does not exists. Going to add it first' %(Section)
+            self.cfg.add_section(Section)
+        self.cfg.set(Section, Key, Value)
+        self.cfg.write(self.writehandle)
+
+
+# file = INIFILE('totalpage.ini')
+# file.Init()
+# num = file.GetValue('Main', 'totalpage', '')
+# print num
+#
+# file.SetValue('Main', 'totalpage', '805')
+# print file.GetValue('Main', 'TotalPage', '0')
+#
+# file.SetValue('DEMO', 'whoami', 'Admin')
+# print file.GetValue('DEMO', 'whoami', 'Admin')

pool/shard000/Python/0007651_1138_01_01_SimpleGIS.py

@@ -0,0 +1,116 @@
+#SimpleGIS.py - A Simple GIS
+
+import turtle as t
+
+# DATA MODEL
+# All layers will have a name, 1+ points, and population count
+NAME = 0
+POINTS = 1
+POP = 2
+
+# Create the state layer
+state = ["COLORADO", [[-109, 37], [-109, 41], [-102, 41], [-102, 37]], 5187582]
+
+# Cities layer list
+# city = [name, [point], population]
+cities = []
+
+# Add Denver
+cities.append(["DENVER",[-104.98, 39.74], 634265])
+# Add Boulder
+cities.append(["BOULDER",[-105.27, 40.02], 98889])
+# Add Durango
+cities.append(["DURANGO",[-107.88,37.28], 17069])
+
+# MAP GRAPHICS RENDERING
+map_width = 800
+map_height = 500
+
+# State Bounding Box
+# Use Python min/max function to get bounding box
+minx = 180
+maxx = -180
+miny = 90
+maxy = -90 
+for x,y in state[POINTS]:
+  if x < minx: minx = x
+  elif x > maxx: maxx = x
+  if y < miny: miny = y
+  elif y > maxy: maxy = y
+# Get earth distance on each axis
+dist_x = maxx - minx
+dist_y = maxy - miny
+
+# Scaling ratio each axis 
+# to map points from world to screen
+x_ratio = map_width / dist_x
+y_ratio = map_height / dist_y
+
+# Function to convert lat/lon to screen coordinates
+def convert(point):
+  lon = point[0]
+  lat = point[1]
+  x = map_width - ((maxx - lon) * x_ratio)
+  y = map_height - ((maxy - lat) * y_ratio)
+  # Python turtle graphics start in the middle of the screen
+  # so we must offset the points so they are centered
+  x = x - (map_width/2)
+  y = y - (map_height/2)
+  return [x,y]
+  
+# Draw the state
+t.up()
+first_pixel = None
+for point in state[POINTS]:
+  print(point)
+  pixel = convert(point)
+  print(pixel)
+  if not first_pixel:
+    first_pixel = pixel
+  t.goto(pixel)
+  t.down()
+# Go back to the first point
+t.goto(first_pixel)
+# Label the state
+t.up()
+t.goto([0,0])
+t.write(state[NAME], align="center", font=("Arial",16,"bold"))
+
+# Draw the cities
+for city in cities:
+  pixel = convert(city[POINTS])
+  t.up()
+  t.goto(pixel)
+  # Place a point for the city
+  t.dot(10)
+  # Label the city
+  t.write(city[NAME] + ", Pop.: " + str(city[POP]), align="left")
+  t.up()
+  
+# Perform an attribute query
+# Question: Which city has the largest population?
+# Write the result but make sure it's under the map
+biggest_city = max(cities, key=lambda city:city[POP])
+t.goto(0, -1*((map_height/2)+20))
+t.write("The biggest city is: " +  biggest_city[NAME])
+
+# Perform a spatial query
+# Question: Which is the western most city?
+# Write the result but make sure it's under the other question
+western_city = min(cities, key=lambda city:city[POINTS])
+t.goto(0, -1*((map_height/2)+40))
+t.write("The western-most city is: " + western_city[NAME])
+  
+# Hide our map pen
+t.pen(shown=False)
+t.done()  
+  
+
+
+
+
+
+
+
+
+

pool/shard000/Python/0007654_071_simplify_path.py

@@ -0,0 +1,40 @@
+"""
+Given an absolute path for a file (Unix-style), simplify it.
+
+For example,
+path = "/home/", => "/home"
+path = "/a/./b/../../c/", => "/c"
+
+Corner Cases:
+
+Did you consider the case where path = "/../"?
+
+In this case, you should return "/".
+
+Another corner case is the path might contain multiple slashes '/' together,
+such as "/home//foo/".
+
+In this case, you should ignore redundant slashes and return "/home/foo".
+"""
+class Solution(object):
+    def simplifyPath(self, path):
+        """
+        :type path: str
+        :rtype: str
+        """
+        soln = []
+        for folder in path.split('/'):
+            if folder == '.' or folder == '':
+                continue
+            elif folder == '..':
+                if len(soln) > 0:
+                    soln.pop()
+            else:
+                soln.append(folder)
+        return '/' + '/'.join(soln)
+
+a = Solution()
+print(a.simplifyPath("/home/") == "/home")
+print(a.simplifyPath("/a/./b/../../c/") == "/c")
+print(a.simplifyPath("/../") == "/")
+print(a.simplifyPath("/home//foo/") == "/home/foo")

pool/shard000/Python/0007657_cmakemakecp.py

@@ -0,0 +1,54 @@
+##
+# Copyright 2009-2020 Ghent University
+#
+# This file is part of EasyBuild,
+# originally created by the HPC team of Ghent University (http://ugent.be/hpc/en),
+# with support of Ghent University (http://ugent.be/hpc),
+# the Flemish Supercomputer Centre (VSC) (https://www.vscentrum.be),
+# Flemish Research Foundation (FWO) (http://www.fwo.be/en)
+# and the Department of Economy, Science and Innovation (EWI) (http://www.ewi-vlaanderen.be/en).
+#
+# https://github.com/easybuilders/easybuild
+#
+# EasyBuild 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 v2.
+#
+# EasyBuild 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 EasyBuild.  If not, see <http://www.gnu.org/licenses/>.
+##
+"""
+EasyBuild support for software configured with CMake but without 'make install' step, implemented as an easyblock
+
+@author: Samuel Moors, Vrije Universiteit Brussel (VUB)
+"""
+from easybuild.easyblocks.generic.cmakemake import CMakeMake
+from easybuild.easyblocks.generic.makecp import MakeCp
+import os
+
+
+class CMakeMakeCp(CMakeMake, MakeCp):
+    """Software configured with CMake but without 'make install' step
+
+    We use the default CMakeMake implementation, and use install_step from MakeCp.
+    """
+
+    @staticmethod
+    def extra_options(extra_vars=None):
+        extra_vars = MakeCp.extra_options(extra_vars)
+        return CMakeMake.extra_options(extra_vars=extra_vars)
+
+    def configure_step(self, srcdir=None, builddir=None):
+        """Configure build using CMake"""
+        return CMakeMake.configure_step(self, srcdir=srcdir, builddir=builddir)
+
+    def install_step(self):
+        """Install by copying specified files and directories."""
+        if self.cfg.get('separate_build_dir', False):
+            self.cfg['start_dir'] = os.path.join(self.builddir, 'easybuild_obj')
+        return MakeCp.install_step(self)

pool/shard000/Python/0007659_server.py

@@ -0,0 +1,139 @@
+#!/usr/bin/python
+
+import xmlrpclib
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+import random, os, datetime, sys, traceback, math
+
+
+start_time = datetime.datetime.now()
+log_dir = "/home/dokstud/lew/logi/%s" % start_time.isoformat()
+
+report_file = "report.csv"
+
+params_sampler = {
+    "progressive_bias"       : lambda: random.uniform (60.0, 120),
+    "progressive_bias_prior" : lambda: random.uniform (0, 40),
+    "proxy_1_bonus"          : lambda: random.uniform (0, 30),
+    "proxy_2_bonus"          : lambda: random.uniform (0, 20),
+    }
+
+params_names  = params_sampler.keys () #csv header
+
+csv_header = ", ".join (params_names) + ", first_is_black, first_win, sgf_file"
+
+params_of_series = []
+games_per_series = 2
+
+gnugo = \
+    "'/home/dokstud/lew/.bin/gnugo-3.8 --mode gtp --chinese-rules" \
+    " --capture-all-dead --positional-superko --level=0'"
+
+libego = \
+    "'/home/dokstud/lew/libego/bin/engine" \
+    " \"LoadGammas /home/dokstud/lew/libego/bin/3x3.gamma\"" \
+    " %s gtp'" 
+
+gtp_set_command = "set"
+
+# TODO seed, cputime
+workers = {}
+idle_workers = {}
+
+def gen_params ():
+    return dict (((p, params_sampler [p] ()) for p in params_names))
+
+
+def params_to_gtp (params):
+    gtp = ""
+    for param_name in params_names:
+        gtp += '"%s %s %f" ' % (gtp_set_command, param_name, params[param_name])
+    return gtp
+
+
+def format_report_line (series_id, first_is_black, first_win, sgf):
+    params = params_of_series [series_id]
+    csv_line = ", ".join ((str(params [param_name]) for param_name in params_names))
+    # scv_line, oh yeah :)
+    return csv_line + (', %d, %d, "%s"' % (first_is_black, first_win, sgf))
+
+
+def report_idling (worker_id):
+    idle_workers [worker_id] = datetime.datetime.now()
+    if (worker_id in workers):
+        print "Warning! Idling worker on worker list."
+    return 0
+   
+ 
+def get_game_setup (worker_id):
+    if (worker_id in workers):
+        print "Warning! Worker already on worker list."
+    if (worker_id in idle_workers):
+        idle_workers.pop (worker_id)
+    workers [worker_id] = datetime.datetime.now()
+
+    global series_id
+    params = gen_params ()
+    series_id = len (params_of_series)
+    params_of_series.append (params)
+    ret = (log_dir,
+           series_id,
+           games_per_series,
+           libego % params_to_gtp (params),
+           gnugo
+           )
+    return ret
+
+
+def report_game_result (worker_id, clog_dir, series_id, result_list):
+    # error handling
+    if (not worker_id in workers):
+        print "Old report from ", worker_id
+        if (clog_dir == log_dir):
+            print "Warning! but the same experiment dir!"
+        return 0;
+    if clog_dir != log_dir: 
+        print "Warning! in pool, but wrong dir!!"
+        return 0
+
+    worker_start = workers.pop (worker_id)
+    f = open (report_file, "a")
+    # TODO check for result length
+    for (first_is_black, first_win, sgf) in result_list:
+        print (first_is_black, first_win, sgf)
+        f.write ("%s\n" % format_report_line (series_id, first_is_black, first_win, sgf))
+    f.close ()
+    return 0
+
+
+def list_workers ():
+    s = "ACTIVE:\n"
+    t_now = datetime.datetime.now()
+    for w in workers:
+        d = t_now - workers[w]
+        mark = " *" if d.seconds > 60 else ""
+        s += "%s %s %s\n" % (w, str(d), mark)
+    s += "IDLE:\n"
+    for w in idle_workers:
+        d = t_now - idle_workers[w]
+        mark = " *" if d.seconds > 60 else ""
+        s += "%s %s %s\n" % (w, str(d), mark)
+    return s
+
+os.makedirs (log_dir)
+os.chdir (log_dir)
+
+address = "students.mimuw.edu.pl", 7553
+server = SimpleXMLRPCServer (address)
+
+server.register_function (get_game_setup, "get_game_setup")
+server.register_function (report_game_result, "report_game_result")
+server.register_function (list_workers, "list_workers")
+server.register_function (report_idling, "report_idling")
+
+print "Listening on port %d..." % address[1]
+
+f = open (report_file, "a")
+f.write ("%s\n" % csv_header)
+f.close ()
+
+server.serve_forever()

pool/shard000/Python/0007664_news.py

@@ -0,0 +1,140 @@
+from datetime import date, datetime
+
+from flask import Blueprint, abort, render_template, request, flash, \
+    redirect, url_for
+from flask_babel import _  # gettext
+from flask_login import current_user
+from sqlalchemy import desc
+from werkzeug.contrib.atom import AtomFeed
+
+from app import db
+from app.decorators import require_role
+from app.forms import init_form
+from app.forms.news import NewsForm
+from app.models.news import News
+from app.roles import Roles
+from app.service import role_service
+
+blueprint = Blueprint('news', __name__, url_prefix='/news')
+
+
+@blueprint.route('/', methods=['GET'])
+@blueprint.route('/<int:page_nr>/', methods=['GET'])
+def list(page_nr=1):
+    items = News.query.filter(News.publish_date <= date.today(),
+                              db.or_(News.archive_date >= date.today(),
+                                     News.archive_date == None),  # noqa
+                              db.or_(current_user.has_paid,
+                                     db.not_(News.needs_paid))) \
+        .order_by(desc(News.publish_date))
+
+    can_write = role_service.user_has_role(current_user, Roles.NEWS_WRITE)
+    return render_template('news/list.htm',
+                           items=items.paginate(page_nr, 10, False),
+                           archive=False, can_write=can_write)
+
+
+@blueprint.route('/all/', methods=['GET'])
+@blueprint.route('/all/<int:page_nr>/', methods=['GET'])
+def all(page_nr=1):
+    return render_template('news/list.htm',
+                           items=News.query.paginate(page_nr, 10, False),
+                           archive=False)
+
+
+@blueprint.route('/archive/', methods=['GET'])
+@blueprint.route('/archive/<int:page_nr>/', methods=['GET'])
+def archive(page_nr=1):
+    items = News.query.filter(db.and_(News.archive_date < date.today(),
+                                      News.archive_date != None))  # noqa
+
+    return render_template('news/list.htm',
+                           items=items.paginate(page_nr, 10, False),
+                           archive=True)
+
+
+@blueprint.route('/create/', methods=['GET', 'POST'])
+@blueprint.route('/edit/<int:news_id>/', methods=['GET', 'POST'])
+@require_role(Roles.NEWS_WRITE)
+def edit(news_id=None):
+    if news_id:
+        news_item = News.query.get_or_404(news_id)
+    else:
+        news_item = News()
+
+    form = init_form(NewsForm, obj=news_item)
+
+    if form.validate_on_submit():
+
+        # fill the news_item with the form entries.
+        form.populate_obj(news_item)
+
+        # Only set writer if post is brand new
+        if not news_item.id:
+            news_item.user_id = current_user.id
+
+        db.session.add(news_item)
+        db.session.commit()
+
+        news_id = news_item.id
+        flash(_('News item saved'), 'success')
+
+        return redirect(url_for('news.view', news_id=news_id))
+
+    return render_template('news/edit.htm', form=form, news_id=news_id)
+
+
+@blueprint.route('/view/', methods=['GET'])
+@blueprint.route('/view/<int:news_id>/', methods=['GET'])
+def view(news_id=None):
+    if not news_id:
+        flash(_('This news item does not exist'), 'danger')
+        return redirect(url_for('news.list'))
+
+    news = News.query.get_or_404(news_id)
+    if not news.can_read():
+        return abort(403)
+
+    can_write = role_service.user_has_role(current_user, Roles.NEWS_WRITE)
+
+    return render_template('news/view_single.htm', news=news,
+                           can_write=can_write)
+
+
+@blueprint.route('/delete/', methods=['GET'])
+@blueprint.route('/delete/<int:news_id>/', methods=['GET'])
+@require_role(Roles.NEWS_WRITE)
+def delete(news_id=None):
+    if not news_id:
+        flash(_('This news item does not exist'), 'danger')
+        return redirect(url_for('news.list'))
+
+    news = News.query.get_or_404(news_id)
+    db.session.delete(news)
+    db.session.commit()
+
+    flash(_('News item succesfully deleted'), 'success')
+
+    return redirect(url_for('news.list'))
+
+
+@blueprint.route('/rss/', methods=['GET'])
+@blueprint.route('/rss/<string:locale>/')
+def rss(locale='en'):
+    name = 'via nieuws' if locale == 'nl' else 'via news'
+    feed = AtomFeed(name, feed_url=request.url, url=request.url_root)
+    items = News.query.filter(News.publish_date <= date.today(),
+                              db.or_(News.archive_date >= date.today(),
+                                     News.archive_date == None),  # noqa
+                              db.or_(db.not_(News.needs_paid))) \
+        .order_by(News.publish_date.desc()).limit(20)
+
+    for item in items:
+        published = datetime.combine(item.publish_date, datetime.min.time())
+        title, content = item.get_localized_title_content(locale)
+        feed.add(title, content, id=item.id, content_type='markdown',
+                 published=published, updated=published,
+                 url=url_for('news.view', news_id=item.id),
+                 author=item.user.name)
+
+    return feed.get_response()

pool/shard000/Python/0007667_rest_api_helper.py

@@ -0,0 +1,238 @@
+#!/usr/bin/python
+#
+# Copyright 2021 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.
+
+from functools import lru_cache
+import logging
+import requests
+from requests import Response
+from typing import Any, Dict, List, Union
+
+from google.datacatalog_connectors.sisense.scrape import \
+    authenticator, constants
+
+
+class RESTAPIHelper:
+
+    def __init__(self, server_address: str, api_version: str, username: str,
+                 password: str):
+
+        self.__server_address = server_address
+        self.__api_version = api_version
+        self.__username = username
+        self.__password = password
+
+        self.__base_api_endpoint = f'{server_address}/api/{api_version}'
+        self.__common_headers = {
+            'Content-Type': constants.JSON_CONTENT_TYPE,
+            'Accept': constants.JSON_CONTENT_TYPE
+        }
+
+        self.__auth_credentials = None
+
+    def get_all_dashboards(self) -> List[Dict[str, Any]]:
+        """Get all Dashboards the user has access to on a given server.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        url = f'{self.__base_api_endpoint}/dashboards'
+        response = requests.get(url=url, headers=self.__common_headers)
+        # ``GET /dashboards`` currently does not support pagination.
+        all_dashboards = self.__get_response_body_or_raise(response)
+
+        # ``GET /dashboards`` returns an array containing a mix of summary
+        # objects for dashboards that are shared with the current user and full
+        # objects for dashboards that are owned by the user. Such summary
+        # objects contain only the ``oid`` and ``lastPublish`` fields.
+        #
+        # So, we check the presence of ``_id`` to determine whether an object
+        # refers to a shared dashboard or not. If ``_id`` is absent, we need to
+        # perform extra API calls to ``GET dashboards/{id}``, passing ``oid``
+        # as parameter, in order to get detailed metadata for each shared
+        # dashboard.
+        shared_dashboards = [
+            dashboard for dashboard in all_dashboards
+            if not dashboard.get('_id')
+        ]
+        for shared_dashboard in shared_dashboards:
+            all_dashboards.remove(shared_dashboard)
+        all_dashboards.extend([
+            self.get_dashboard(dashboard.get('oid'))
+            for dashboard in shared_dashboards
+        ])
+
+        return all_dashboards
+
+    def get_dashboard(self, dashboard_id: str) -> Dict[str, Any]:
+        """Get a specific Dashboard.
+
+        Returns:
+            A Dashboard object.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+        url = f'{self.__base_api_endpoint}/dashboards/{dashboard_id}'
+        response = requests.get(url=url, headers=self.__common_headers)
+        return self.__get_response_body_or_raise(response)
+
+    def get_all_folders(self) -> List[Dict[str, Any]]:
+        """Get all Folders the user has access to on a given server.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        # Sisense can return the folders in flat (default) or tree structures.
+        # We decided for flat because it supports standard pagination handling
+        # (paginating a tree structure would require extra programming effort).
+        url = f'{self.__base_api_endpoint}/folders?structure=flat'
+        return self.__get_list_using_pagination(base_url=url,
+                                                results_per_page=50)
+
+    @lru_cache(maxsize=128)
+    def get_user(self, user_id: str) -> Dict[str, Any]:
+        """Get a specific User.
+
+        Returns:
+            A User object.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+        url = f'{self.__base_api_endpoint}/users/{user_id}'
+        response = requests.get(url=url, headers=self.__common_headers)
+        return self.__get_response_body_or_raise(response)
+
+    def get_widgets(self, dashboard_id) -> List[Dict[str, Any]]:
+        """Get all Widgets belonging to a given Dashboard.
+
+        Returns:
+            A ``list``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+        self.__set_up_auth()
+
+        url = f'{self.__base_api_endpoint}/dashboards/{dashboard_id}/widgets'
+        return self.__get_list_using_pagination(base_url=url,
+                                                results_per_page=50)
+
+    def __set_up_auth(self) -> None:
+        if self.__auth_credentials:
+            return
+
+        self.__auth_credentials = \
+            authenticator.Authenticator.authenticate(
+                self.__server_address,
+                self.__api_version,
+                self.__username,
+                self.__password)
+
+        self.__common_headers[constants.AUTHORIZATION_HEADER_NAME] = \
+            f'{constants.BEARER_TOKEN_PREFIX}' \
+            f' {self.__auth_credentials["access_token"]}'
+
+    def __get_list_using_pagination(self,
+                                    base_url: str,
+                                    results_per_page: int,
+                                    id_field='oid') -> List[Dict[str, Any]]:
+        """Get a ``List`` using pagination.
+
+        Args:
+            base_url: The url to which the ``skip`` and ``limit`` query
+              parameters will be appended to handle pagination accordingly.
+            results_per_page: The number of results per page. Must be greater
+              than 1.
+
+        Returns:
+            A ``list``.
+        """
+        if results_per_page <= 1:
+            raise ValueError('results_per_page must be greater than 1')
+
+        results = []
+        query_param_prefix = '?' if '?' not in base_url else '&'
+
+        page_count = 0
+        page_results = []
+        # Sisense APIs may add more results to some pages than specified by the
+        # ``results_per_page`` argument. It happens in the ``GET /folders``
+        # pages, for instance: all pages include the ``rootFolder``, resulting
+        # in ``results_per_page + 1`` folders in all pages but the last.
+        # Given this behavior, we need ``results_per_page`` to be greater than
+        # ``1`` and to use the ``>=`` operator to decide between executing the
+        # ``while`` loop or not, to avoid issues.
+        while page_count == 0 or len(page_results) >= results_per_page:
+            offset = page_count * results_per_page
+            url = f'{base_url}{query_param_prefix}skip={offset}' \
+                  f'&limit={results_per_page}'
+            response = requests.get(url=url, headers=self.__common_headers)
+            page_results = self.__get_response_body_or_raise(response)
+            results.extend(page_results)
+            page_count += 1
+            logging.info(f'page {page_count}: {len(page_results)} results')
+
+        logging.info('')
+        logging.info('Removing potential duplicates...')
+        # Set comprehension is used to remove potential duplicates after
+        # merging the results, e.g.: the ``rootFolder`` that comes in all
+        # ``GET /folders`` pages.
+        unique_ids = {result.get(id_field) for result in results}
+
+        unique_results = []
+        for unique_id in unique_ids:
+            unique_results.append(
+                next(result for result in results
+                     if result.get(id_field) == unique_id))
+
+        return unique_results
+
+    @classmethod
+    def __get_response_body_or_raise(
+            cls,
+            response: Response) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """Get the response body on successful API call or raise an exception.
+
+        Returns:
+            A ``Dict`` or ``List``.
+
+        Raises:
+            Exception: If the API returns any status code than ``200``.
+        """
+
+        status_code = response.status_code
+
+        if status_code == 200:
+            return response.json()
+
+        # Raise exception for all status codes other than ``200`` to let the
+        # caller know what went wrong.
+        error = response.json().get('error') or {}
+        logging.warning('error on API call: %s', error)
+        raise Exception(error.get('message'))

pool/shard000/Python/0007668_grove_temp.py

@@ -0,0 +1,20 @@
+# Pyboard code for reading a grove temp sensor connected to X1
+
+import pyb
+import math
+
+B = 4275
+
+temp_adc = pyb.ADC('X1')
+
+def read_temp():
+    temp_raw = temp_adc.read()
+    R = (4095 / temp_raw) - 1.0
+    
+    temp = 1.0 / (math.log(R) / B + 1/298.15) - 273.15
+    return temp
+
+while True:
+    t = read_temp()
+    print('temp =', t)
+    pyb.delay(1000)