commit stringlengths 40 40 | subject stringlengths 1 1.49k | old_file stringlengths 4 311 | new_file stringlengths 4 311 | new_contents stringlengths 1 29.8k | old_contents stringlengths 0 9.9k | lang stringclasses 3 values | proba float64 0 1 |
|---|---|---|---|---|---|---|---|
6722b8494a847ca62f77874f41ee47abc08c2a09 | Move the images to the left | flumotion/component/converters/overlay/genimg.py | flumotion/component/converters/overlay/genimg.py | # -*- Mode: Python -*-
# vi:si:et:sw=4:sts=4:ts=4
#
# flumotion/component/converters/overlay/genimg.py: overlay image generator
#
# Flumotion - a streaming media server
# Copyright (C) 2004 Fluendo (www.fluendo.com)
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# See "LICENSE.GPL" in the source distribution for more information.
# This program is also licensed under the Flumotion license.
# See "LICENSE.Flumotion" in the source distribution for more information.
import os
from PIL import Image
from PIL import ImageChops
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageOps
directory = os.path.split(os.path.abspath(__file__))[0]
fontpath = os.path.join(directory, 'Vera.ttf')
logopath = directory
fluendoLogoPath = os.path.join(logopath, 'fluendo.24x24.png')
ccLogoPath = os.path.join(logopath, 'cc.24x24.png')
xiphLogoPath = os.path.join(logopath, 'xiph.24x24.png')
TEXT_XOFFSET = 4
TEXT_YOFFSET = 4
WIDTH = 24
BORDER = 4
FONT_SIZE = 22
def generate_overlay(filename, text, show_fluendo, show_cc, show_xiph,
width, height):
image = Image.new("RGBA", (width, height))
draw = ImageDraw.Draw(image) # inheriting color mode
font = ImageFont.truetype(fontpath, FONT_SIZE)
draw.text((TEXT_XOFFSET+2, TEXT_YOFFSET+2),
text, font=font, fill='black')
draw.text((TEXT_XOFFSET, TEXT_YOFFSET),
text, font=font)
# How many logos we're going to show
logos = len([i for i in (show_fluendo, show_cc, show_xiph) if i]) - 1
# This is really *NOT* the optimal way of doing this.
# We should really find out a better way of adding an image on
# another image (with an offset)
imax = max(width, height)
y_corr = -(abs(width - height) + WIDTH + BORDER)
if show_xiph:
xiph = Image.open(xiphLogoPath)
xiph = ImageOps.expand(xiph, imax)
xiph = ImageChops.offset(xiph, -width + (WIDTH*logos), y_corr)
image = ImageChops.add_modulo(image, xiph)
logos -= 1
if show_cc:
cc = Image.open(ccLogoPath)
cc = ImageOps.expand(cc, imax)
cc = ImageChops.offset(cc, -width + (WIDTH*logos), y_corr)
image = ImageChops.add_modulo(image, cc)
logos -= 1
if show_fluendo:
fluendo = Image.open(fluendoLogoPath)
fluendo = ImageOps.expand(fluendo, imax)
fluendo = ImageChops.offset(fluendo, -width, y_corr)
image = ImageChops.add_modulo(image, fluendo)
if os.path.exists(filename):
os.unlink(filename)
image.save(filename, 'png')
if __name__ == '__main__':
#generate_overlay('test.png', 'Testing', True, True, True, 320, 240)
generate_overlay('test.png', 'Testing', True, True, True, 320, 240)
| # -*- Mode: Python -*-
# vi:si:et:sw=4:sts=4:ts=4
#
# flumotion/component/converters/overlay/genimg.py: overlay image generator
#
# Flumotion - a streaming media server
# Copyright (C) 2004 Fluendo (www.fluendo.com)
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
# See "LICENSE.GPL" in the source distribution for more information.
# This program is also licensed under the Flumotion license.
# See "LICENSE.Flumotion" in the source distribution for more information.
import os
from PIL import Image
from PIL import ImageChops
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageOps
directory = os.path.split(os.path.abspath(__file__))[0]
fontpath = os.path.join(directory, 'Vera.ttf')
logopath = directory
fluendoLogoPath = os.path.join(logopath, 'fluendo.24x24.png')
ccLogoPath = os.path.join(logopath, 'cc.24x24.png')
xiphLogoPath = os.path.join(logopath, 'xiph.24x24.png')
TEXT_XOFFSET = 4
TEXT_YOFFSET = 4
WIDTH = 24
BORDER = 4
FONT_SIZE = 22
def generate_overlay(filename, text, show_fluendo, show_cc, show_xiph,
width, height):
image = Image.new("RGBA", (width, height))
draw = ImageDraw.Draw(image) # inheriting color mode
font = ImageFont.truetype(fontpath, FONT_SIZE)
draw.text((TEXT_XOFFSET+2, TEXT_YOFFSET+2),
text, font=font, fill='black')
draw.text((TEXT_XOFFSET, TEXT_YOFFSET),
text, font=font)
# How many logos we're going to show
logos = len([i for i in (show_fluendo, show_cc, show_xiph) if i])
# This is really *NOT* the optimal way of doing this.
# We should really find out a better way of adding an image on
# another image (with an offset)
imax = max(width, height)
y_corr = -(abs(width - height) + WIDTH + BORDER)
if show_xiph:
xiph = Image.open(xiphLogoPath)
xiph = ImageOps.expand(xiph, imax)
xiph = ImageChops.offset(xiph, logos * -(WIDTH + BORDER), y_corr)
image = ImageChops.add_modulo(image, xiph)
logos -= 1
if show_cc:
cc = Image.open(ccLogoPath)
cc = ImageOps.expand(cc, imax)
cc = ImageChops.offset(cc, logos * -(WIDTH + BORDER), y_corr)
image = ImageChops.add_modulo(image, cc)
logos -= 1
if show_fluendo:
fluendo = Image.open(fluendoLogoPath)
fluendo = ImageOps.expand(fluendo, imax)
fluendo = ImageChops.offset(fluendo, -(WIDTH + BORDER), y_corr)
image = ImageChops.add_modulo(image, fluendo)
if os.path.exists(filename):
os.unlink(filename)
image.save(filename, 'png')
if __name__ == '__main__':
generate_overlay('test.png', 'Testing', True, True, True, 320, 240)
| Python | 0.000003 |
f66cee94d2ae4ba12cc8d56c40be0d2e07f69a5a | Tag 0.0.2 | swingtix/bookkeeper/__init__.py | swingtix/bookkeeper/__init__.py | __VERSION__='0.0.1.1-29-gdc751f0M'
| __VERSION__='0.0.1.1'
| Python | 0.000002 |
88a7b3251d96513111e20282e840d5e0f68aa9c8 | Remove unused import | InvenTree/label/apps.py | InvenTree/label/apps.py | import os
import shutil
import logging
from django.apps import AppConfig
from django.conf import settings
logger = logging.getLogger(__name__)
class LabelConfig(AppConfig):
name = 'label'
def ready(self):
"""
This function is called whenever the label app is loaded
"""
self.create_stock_item_labels()
self.create_stock_location_labels()
def create_stock_item_labels(self):
"""
Create database entries for the default StockItemLabel templates,
if they do not already exist
"""
try:
from .models import StockItemLabel
except:
# Database might not by ready yet
return
src_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'templates',
'stockitem',
)
dst_dir = os.path.join(
settings.MEDIA_ROOT,
'label',
'inventree',
'stockitem',
)
if not os.path.exists(dst_dir):
logger.info(f"Creating missing directory: '{dst_dir}'")
os.makedirs(dst_dir, exist_ok=True)
labels = [
{
'file': 'qr.html',
'name': 'QR Code',
'description': 'Simple QR code label',
},
]
for label in labels:
filename = os.path.join(
'label',
'inventree',
'stockitem',
label['file'],
)
# Check if the file exists in the media directory
src_file = os.path.join(src_dir, label['file'])
dst_file = os.path.join(settings.MEDIA_ROOT, filename)
if not os.path.exists(dst_file):
logger.info(f"Copying label template '{dst_file}'")
shutil.copyfile(src_file, dst_file)
try:
# Check if a label matching the template already exists
if StockItemLabel.objects.filter(label=filename).exists():
continue
logger.info(f"Creating entry for StockItemLabel '{label['name']}'")
StockItemLabel.objects.create(
name=label['name'],
description=label['description'],
label=filename,
filters='',
enabled=True
)
except:
pass
def create_stock_location_labels(self):
"""
Create database entries for the default StockItemLocation templates,
if they do not already exist
"""
try:
from .models import StockLocationLabel
except:
# Database might not yet be ready
return
src_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'templates',
'stocklocation',
)
dst_dir = os.path.join(
settings.MEDIA_ROOT,
'label',
'inventree',
'stocklocation',
)
if not os.path.exists(dst_dir):
logger.info(f"Creating missing directory: '{dst_dir}'")
os.makedirs(dst_dir, exist_ok=True)
labels = [
{
'file': 'qr.html',
'name': 'QR Code',
'description': 'Simple QR code label',
},
{
'file': 'qr_and_text.html',
'name': 'QR and text',
'description': 'Label with QR code and name of location',
}
]
for label in labels:
filename = os.path.join(
'label',
'inventree',
'stocklocation',
label['file'],
)
# Check if the file exists in the media directory
src_file = os.path.join(src_dir, label['file'])
dst_file = os.path.join(settings.MEDIA_ROOT, filename)
if not os.path.exists(dst_file):
logger.info(f"Copying label template '{dst_file}'")
shutil.copyfile(src_file, dst_file)
try:
# Check if a label matching the template already exists
if StockLocationLabel.objects.filter(label=filename).exists():
continue
logger.info(f"Creating entry for StockLocationLabel '{label['name']}'")
StockLocationLabel.objects.create(
name=label['name'],
description=label['description'],
label=filename,
filters='',
enabled=True
)
except:
pass
| import os
import shutil
import logging
from django.db.utils import IntegrityError
from django.apps import AppConfig
from django.conf import settings
logger = logging.getLogger(__name__)
class LabelConfig(AppConfig):
name = 'label'
def ready(self):
"""
This function is called whenever the label app is loaded
"""
self.create_stock_item_labels()
self.create_stock_location_labels()
def create_stock_item_labels(self):
"""
Create database entries for the default StockItemLabel templates,
if they do not already exist
"""
try:
from .models import StockItemLabel
except:
# Database might not by ready yet
return
src_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'templates',
'stockitem',
)
dst_dir = os.path.join(
settings.MEDIA_ROOT,
'label',
'inventree',
'stockitem',
)
if not os.path.exists(dst_dir):
logger.info(f"Creating missing directory: '{dst_dir}'")
os.makedirs(dst_dir, exist_ok=True)
labels = [
{
'file': 'qr.html',
'name': 'QR Code',
'description': 'Simple QR code label',
},
]
for label in labels:
filename = os.path.join(
'label',
'inventree',
'stockitem',
label['file'],
)
# Check if the file exists in the media directory
src_file = os.path.join(src_dir, label['file'])
dst_file = os.path.join(settings.MEDIA_ROOT, filename)
if not os.path.exists(dst_file):
logger.info(f"Copying label template '{dst_file}'")
shutil.copyfile(src_file, dst_file)
try:
# Check if a label matching the template already exists
if StockItemLabel.objects.filter(label=filename).exists():
continue
logger.info(f"Creating entry for StockItemLabel '{label['name']}'")
StockItemLabel.objects.create(
name=label['name'],
description=label['description'],
label=filename,
filters='',
enabled=True
)
except:
pass
def create_stock_location_labels(self):
"""
Create database entries for the default StockItemLocation templates,
if they do not already exist
"""
try:
from .models import StockLocationLabel
except:
# Database might not yet be ready
return
src_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
'templates',
'stocklocation',
)
dst_dir = os.path.join(
settings.MEDIA_ROOT,
'label',
'inventree',
'stocklocation',
)
if not os.path.exists(dst_dir):
logger.info(f"Creating missing directory: '{dst_dir}'")
os.makedirs(dst_dir, exist_ok=True)
labels = [
{
'file': 'qr.html',
'name': 'QR Code',
'description': 'Simple QR code label',
},
{
'file': 'qr_and_text.html',
'name': 'QR and text',
'description': 'Label with QR code and name of location',
}
]
for label in labels:
filename = os.path.join(
'label',
'inventree',
'stocklocation',
label['file'],
)
# Check if the file exists in the media directory
src_file = os.path.join(src_dir, label['file'])
dst_file = os.path.join(settings.MEDIA_ROOT, filename)
if not os.path.exists(dst_file):
logger.info(f"Copying label template '{dst_file}'")
shutil.copyfile(src_file, dst_file)
try:
# Check if a label matching the template already exists
if StockLocationLabel.objects.filter(label=filename).exists():
continue
logger.info(f"Creating entry for StockLocationLabel '{label['name']}'")
StockLocationLabel.objects.create(
name=label['name'],
description=label['description'],
label=filename,
filters='',
enabled=True
)
except:
pass
| Python | 0.000001 |
101dae4f5a12605a791b0f81fb2ff599cbf2facb | Return early | mir/dlsite/cmd/dlorg.py | mir/dlsite/cmd/dlorg.py | # Copyright (C) 2016, 2017 Allen Li
#
# 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.
"""Organize DLsite works."""
import argparse
import logging
from pathlib import Path
import sys
from mir.dlsite import api
from mir.dlsite import org
logger = logging.getLogger(__name__)
def main(argv):
logging.basicConfig(level='DEBUG')
parser = argparse.ArgumentParser(prog=argv[0],
description=__doc__)
parser.add_argument('top_dir', nargs='?', default=Path.cwd(),
type=Path)
parser.add_argument('-n', '--dry-run', action='store_true')
parser.add_argument('-a', '--all', action='store_true')
args = parser.parse_args(argv[1:])
paths = list(org.find_works(args.top_dir))
if not args.all:
paths = [p for p in paths if len(p.parts) == 1]
with api.get_fetcher() as fetcher:
renames = list(org.calculate_path_renames(fetcher, paths))
if args.dry_run:
for r in renames:
logger.info('Would rename %s to %s', r.old, r.new)
return 0
for r in renames:
r.execute(args.top_dir)
org.remove_empty_dirs(args.top_dir)
paths = org.apply_renames(paths, renames)
with api.get_fetcher() as fetcher:
for p in paths:
org.add_dlsite_files(fetcher, p)
return 0
if __name__ == '__main__':
sys.exit(main(sys.argv))
| # Copyright (C) 2016, 2017 Allen Li
#
# 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.
"""Organize DLsite works."""
import argparse
import logging
from pathlib import Path
import sys
from mir.dlsite import api
from mir.dlsite import org
logger = logging.getLogger(__name__)
def main(argv):
logging.basicConfig(level='DEBUG')
parser = argparse.ArgumentParser(prog=argv[0],
description=__doc__)
parser.add_argument('top_dir', nargs='?', default=Path.cwd(),
type=Path)
parser.add_argument('-n', '--dry-run', action='store_true')
parser.add_argument('-a', '--all', action='store_true')
args = parser.parse_args(argv[1:])
paths = list(org.find_works(args.top_dir))
if not args.all:
paths = [p for p in paths if len(p.parts) == 1]
with api.get_fetcher() as fetcher:
renames = list(org.calculate_path_renames(fetcher, paths))
if args.dry_run:
for r in renames:
logger.info('Would rename %s to %s', r.old, r.new)
else:
for r in renames:
r.execute(args.top_dir)
org.remove_empty_dirs(args.top_dir)
paths = org.apply_renames(paths, renames)
with api.get_fetcher() as fetcher:
for p in paths:
org.add_dlsite_files(fetcher, p)
return 0
if __name__ == '__main__':
sys.exit(main(sys.argv))
| Python | 0.000233 |
6035ef056f6ca028828faad68a0a0954e581300e | Set L=4 to try other topology | ext/viro_constant.py | ext/viro_constant.py | # Manually set L
L = 4
# OPERATIONS
VIRO_DATA_OP = 0x0000
VIRO_DATA = 0x0802
VIRO_CONTROL = 0x0803
RDV_PUBLISH = 0x1000
RDV_QUERY = 0x2000
RDV_REPLY = 0x3000
DISCOVERY_ECHO_REQUEST = 0x4000
DISCOVERY_ECHO_REPLY = 0x5000
GW_WITHDRAW = 0x6000
RDV_WITHDRAW = 0x7000
# OTHER PARTS OF THE HEADER
HTYPE = 0x1
PTYPE = 0x0800
HLEN = 0x06
PLEN = 0x04
# Per the CSCI 5221 Project 2 assignment document:
# "We limit the maximal number of < Gateway; Nexthop > pairs in each level to 3."
MAX_GW_PER_LEVEL = 3
MAX_GW_PER_RDV_REPLY = MAX_GW_PER_LEVEL
# HARDWARE ADDRESS FOR THE VEIL MASTER
VEIL_MASTER_MAC = "00:00:00:00:00:00"
# An arbitrary/fake MAC address that seems to be used in various places
FAKE_MAC = '00:14:4f:e2:b3:70'
# OFFSET FOR THE OPER
OPER_OFFSET = 6
OPER_LEN = 2
# OFFSET FOR THE ECHO_SRC_VID
ECHO_SRC_OFFSET = 8
# The following _TIME parameter are all measured in seconds
ROUND_TIME = 10 # Time between "bottom up" rounds for routing table construction (RDV_PUBLISH / RDV_QUERY)
DISCOVER_TIME = 5 # Time between checking neighbor status
FAILURE_TIME = 7 # Time between checks for failures
# OPERATION NUMBER TO STRING MAPPING
OPERATION_NAMES = {
0x1000: 'RDV_PUBLISH',
0x2000: 'RDV_QUERY',
0x3000: 'RDV_REPLY',
0x4000: 'DISCOVERY_ECHO_REQUEST',
0x5000: 'DISCOVERY_ECHO_REPLY',
0x6000: 'GW_WITHDRAW',
0x7000: 'RDV_WITHDRAW'
}
| # Manually set L
L = 3
# OPERATIONS
VIRO_DATA_OP = 0x0000
VIRO_DATA = 0x0802
VIRO_CONTROL = 0x0803
RDV_PUBLISH = 0x1000
RDV_QUERY = 0x2000
RDV_REPLY = 0x3000
DISCOVERY_ECHO_REQUEST = 0x4000
DISCOVERY_ECHO_REPLY = 0x5000
GW_WITHDRAW = 0x6000
RDV_WITHDRAW = 0x7000
# OTHER PARTS OF THE HEADER
HTYPE = 0x1
PTYPE = 0x0800
HLEN = 0x06
PLEN = 0x04
# Per the CSCI 5221 Project 2 assignment document:
# "We limit the maximal number of < Gateway; Nexthop > pairs in each level to 3."
MAX_GW_PER_LEVEL = 3
MAX_GW_PER_RDV_REPLY = MAX_GW_PER_LEVEL
# HARDWARE ADDRESS FOR THE VEIL MASTER
VEIL_MASTER_MAC = "00:00:00:00:00:00"
# An arbitrary/fake MAC address that seems to be used in various places
FAKE_MAC = '00:14:4f:e2:b3:70'
# OFFSET FOR THE OPER
OPER_OFFSET = 6
OPER_LEN = 2
# OFFSET FOR THE ECHO_SRC_VID
ECHO_SRC_OFFSET = 8
# The following _TIME parameter are all measured in seconds
ROUND_TIME = 10 # Time between "bottom up" rounds for routing table construction (RDV_PUBLISH / RDV_QUERY)
DISCOVER_TIME = 5 # Time between checking neighbor status
FAILURE_TIME = 7 # Time between checks for failures
# OPERATION NUMBER TO STRING MAPPING
OPERATION_NAMES = {
0x1000: 'RDV_PUBLISH',
0x2000: 'RDV_QUERY',
0x3000: 'RDV_REPLY',
0x4000: 'DISCOVERY_ECHO_REQUEST',
0x5000: 'DISCOVERY_ECHO_REPLY',
0x6000: 'GW_WITHDRAW',
0x7000: 'RDV_WITHDRAW'
}
| Python | 0.000002 |
fd1a6abb003832919eea99fce05e06188889527c | Change the urls import line. Fix #6 | cerberos/urls.py | cerberos/urls.py | # -*- coding: utf-8 -*-
from django.conf.urls import *
from cerberos.views import *
urlpatterns = patterns('',
)
| # -*- coding: utf-8 -*-
from django.conf.urls.defaults import *
from cerberos.views import *
urlpatterns = patterns('',
)
| Python | 0.000657 |
95778ca8d83a7c3b4c87cfd5b89b470abfc58f6a | support to assign version and additional filter | check_version.py | check_version.py | #!/usr/bin/env python
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# See LICENSE for more details.
#
# Copyright (c) 2018 ScyllaDB
import logging
from avocado import Test
class CheckVersionDB(object):
def __init__(self, host, user, passwd):
self.host = host
self.user = user
self.passwd = passwd
self.db_name = 'housekeeping'
self.connect()
self.log = logging.getLogger('check_version_db')
def connect(self):
import MySQLdb
self.db = MySQLdb.connect(host=self.host,
user=self.user,
passwd=self.passwd,
db=self.db_name)
self.cursor = self.db.cursor()
def close(self):
self.db.close()
def reconnect(self):
self.close()
self.connect()
def commit(self):
self.db.commit()
def execute(self, sql, verbose=True):
self.log.debug('SQL: {}'.format(sql))
self.cursor.execute(sql)
ret = self.cursor.fetchall()
self.log.debug('RET: {}'.format(ret))
return ret
def get_last_id(self, uuid, repoid, version=None, table='housekeeping.repo', add_filter=None):
# get last id of test uuid
last_id = 0
sql = 'select * from {} where uuid="{}" and repoid="{}"'.format(table, uuid, repoid)
if version:
sql += ' and version="{}" '.format(version)
if add_filter:
sql += ' {}'.format(add_filter)
sql += ' order by -dt limit 1'
ret = self.execute(sql)
if len(ret) > 0:
last_id = ret[0][0]
return last_id
def check_new_record(self, uuid, repoid, version=None, last_id=0, table='housekeeping.repo', add_filter=None):
# verify download repo of test uuid is collected to repo table
self.commit()
sql = 'select * from {} where uuid="{}" and repoid="{}"'.format(table, uuid, repoid)
if version:
sql += ' and version="{}" '.format(version)
if add_filter:
sql += ' {}'.format(add_filter)
sql += ' and id > {}'.format(last_id)
ret = self.execute(sql)
return len(ret) > 0
class EmptyTest(Test):
"""
Workaround:
We want Avocado to copy this module to VM, it will be used by scylla-artifacts.py
But Avocado will raise error if the module doesn't contain valid subtest.
So we add this empty test.
:avocado: enable
"""
def test_empty(self):
pass
| #!/usr/bin/env python
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# See LICENSE for more details.
#
# Copyright (c) 2018 ScyllaDB
import logging
from avocado import Test
class CheckVersionDB(object):
def __init__(self, host, user, passwd):
self.host = host
self.user = user
self.passwd = passwd
self.db_name = 'housekeeping'
self.connect()
self.log = logging.getLogger('check_version_db')
def connect(self):
import MySQLdb
self.db = MySQLdb.connect(host=self.host,
user=self.user,
passwd=self.passwd,
db=self.db_name)
self.cursor = self.db.cursor()
def close(self):
self.db.close()
def reconnect(self):
self.close()
self.connect()
def commit(self):
self.db.commit()
def execute(self, sql, verbose=True):
self.log.debug('SQL: {}'.format(sql))
self.cursor.execute(sql)
ret = self.cursor.fetchall()
self.log.debug('RET: {}'.format(ret))
return ret
def get_last_id(self, uuid, repoid, version, table='housekeeping.repo'):
# get last id of test uuid
last_id = 0
ret = self.execute('select * from {} where uuid="{}" and repoid="{}" and version="{}" order by -dt limit 1'.format(table, uuid, repoid, version))
if len(ret) > 0:
last_id = ret[0][0]
return last_id
def check_new_record(self, uuid, repoid, version, last_id, table='housekeeping.repo'):
# verify download repo of test uuid is collected to repo table
self.commit()
ret = self.execute('select * from {} where uuid="{}" and repoid="{}" and version="{}" and id > {}'.format(table, uuid, repoid, version, last_id))
return len(ret) > 0
class EmptyTest(Test):
"""
Workaround:
We want Avocado to copy this module to VM, it will be used by scylla-artifacts.py
But Avocado will raise error if the module doesn't contain valid subtest.
So we add this empty test.
:avocado: enable
"""
def test_empty(self):
pass
| Python | 0 |
bdcdeaea6eb760d91690439da43d72ef0673df48 | change replace statement | fabfile/instagram.py | fabfile/instagram.py | #!/usr/bin/env python
import csv
import json
from fabric.api import task
import requests
FIELDNAMES = ['date', 'username', 'caption', 'instagram_url', 'image', 'image_url', 'embed_code', 'approved']
class Photo(object):
def __init__(self, **kwargs):
for field in FIELDNAMES:
if kwargs[field]:
setattr(self, field, kwargs[field])
setattr(
self,
'local_img_id',
self.image_url\
.split(u'/')[-1]\
.replace('_n.jpg', '.jpg'))
setattr(
self,
'local_img_url',
'assets/instagram/nprparty-instagram-%s' % self.image_url\
.split(u'/')[-1]\
.replace('_n.jpg', '.jpg'))
def get_photo_csv():
r = requests.get('https://docs.google.com/spreadsheets/d/1DAirjcVoeeLtfpurOzJIqqgLqOWClxCOCD_wIkMUscI/export?format=csv')
with open('data/photos.csv', 'wb') as writefile:
writefile.write(r.content)
def parse_photo_csv():
with open('data/photos.csv', 'rb') as readfile:
photos = list(csv.DictReader(readfile, fieldnames=FIELDNAMES))
print "Processing %s entries from Google Docs." % len(photos)
payload = []
for photo in photos:
if photo['approved'] != '':
r = requests.get(photo['image_url'])
if r.status_code == 200:
p = Photo(**photo)
payload.append(p.__dict__)
with open('www/assets/instagram/nprparty-instagram-%s' % p.local_img_id, 'wb') as writefile:
writefile.write(r.content)
print "Writing %s photos to JSON." % len(payload)
with open('www/live-data/photos.json', 'wb') as writefile:
writefile.write(json.dumps(payload))
@task
def get_photos():
get_photo_csv()
parse_photo_csv()
| #!/usr/bin/env python
import csv
import json
from fabric.api import task
import requests
FIELDNAMES = ['date', 'username', 'caption', 'instagram_url', 'image', 'image_url', 'embed_code', 'approved']
class Photo(object):
def __init__(self, **kwargs):
for field in FIELDNAMES:
if kwargs[field]:
setattr(self, field, kwargs[field])
setattr(
self,
'local_img_id',
self.image_url\
.split(u'/')[-1]\
.replace('_8.jpg', '.jpg'))
setattr(
self,
'local_img_url',
'assets/instagram/nprparty-instagram-%s' % self.image_url\
.split(u'/')[-1]\
.replace('_n.jpg', '.jpg'))
def get_photo_csv():
r = requests.get('https://docs.google.com/spreadsheets/d/1DAirjcVoeeLtfpurOzJIqqgLqOWClxCOCD_wIkMUscI/export?format=csv')
with open('data/photos.csv', 'wb') as writefile:
writefile.write(r.content)
def parse_photo_csv():
with open('data/photos.csv', 'rb') as readfile:
photos = list(csv.DictReader(readfile, fieldnames=FIELDNAMES))
print "Processing %s entries from Google Docs." % len(photos)
payload = []
for photo in photos:
if photo['approved'] != '':
r = requests.get(photo['image_url'])
if r.status_code == 200:
p = Photo(**photo)
payload.append(p.__dict__)
with open('www/assets/instagram/nprparty-instagram-%s' % p.local_img_id, 'wb') as writefile:
writefile.write(r.content)
print "Writing %s photos to JSON." % len(payload)
with open('www/live-data/photos.json', 'wb') as writefile:
writefile.write(json.dumps(payload))
@task
def get_photos():
get_photo_csv()
parse_photo_csv()
| Python | 0.000266 |
54282a1b7c2ea707506078483cf806e9521f264c | update version number | fabsetup/_version.py | fabsetup/_version.py | __version__ = "0.7.7"
| __version__ = "0.7.6"
| Python | 0.000002 |
a0ac28b8d55654e6da02b96cb7c85270a3267f3d | Add links for development_status and maintainers keys | template/module/__manifest__.py | template/module/__manifest__.py | # -*- coding: utf-8 -*-
# Copyright <YEAR(S)> <AUTHOR(S)>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Module name",
"summary": "Module summary",
"version": "11.0.1.0.0",
# see https://odoo-community.org/page/development-status
"development_status": "Alpha|Beta|Production/Stable|Mature",
"category": "Uncategorized",
"website": "https://github.com/OCA/<repo>" or "https://github.com/OCA/<repo>/tree/<branch>/<addon>",
"author": "<AUTHOR(S)>, Odoo Community Association (OCA)",
# see https://odoo-community.org/page/maintainer-role for a description of the maintainer role and responsibilities
"maintainers": ["your-github-login"],
"license": "AGPL-3",
"application": False,
"installable": True,
"pre_init_hook": "pre_init_hook",
"post_init_hook": "post_init_hook",
"post_load": "post_load",
"uninstall_hook": "uninstall_hook",
"external_dependencies": {
"python": [],
"bin": [],
},
"depends": [
"base",
],
"data": [
"security/some_model_security.xml",
"security/ir.model.access.csv",
"templates/assets.xml",
"views/report_name.xml",
"views/res_partner_view.xml",
"wizards/wizard_model_view.xml",
],
"demo": [
"demo/assets.xml",
"demo/res_partner_demo.xml",
],
"qweb": [
"static/src/xml/module_name.xml",
]
}
| # -*- coding: utf-8 -*-
# Copyright <YEAR(S)> <AUTHOR(S)>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Module name",
"summary": "Module summary",
"version": "11.0.1.0.0",
"development_status": "Alpha|Beta|Production/Stable|Mature",
"category": "Uncategorized",
"website": "https://github.com/OCA/<repo>" or "https://github.com/OCA/<repo>/tree/<branch>/<addon>",
"author": "<AUTHOR(S)>, Odoo Community Association (OCA)",
"maintainers": [],
"license": "AGPL-3",
"application": False,
"installable": True,
"pre_init_hook": "pre_init_hook",
"post_init_hook": "post_init_hook",
"post_load": "post_load",
"uninstall_hook": "uninstall_hook",
"external_dependencies": {
"python": [],
"bin": [],
},
"depends": [
"base",
],
"data": [
"security/some_model_security.xml",
"security/ir.model.access.csv",
"templates/assets.xml",
"views/report_name.xml",
"views/res_partner_view.xml",
"wizards/wizard_model_view.xml",
],
"demo": [
"demo/assets.xml",
"demo/res_partner_demo.xml",
],
"qweb": [
"static/src/xml/module_name.xml",
]
}
| Python | 0 |
7f63e544c914ae4f08436f64d679d6965937a43c | fix login | login.py | login.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: Yuande Liu <miracle (at) gmail.com>
from settings import USERNAME, PASSWORD
import requests
import lxml.html
requests.adapters.DEFAULT_RETRIES = 3
def get_session():
""".. :py:method::
"""
if not hasattr(get_session, 'session'):
session = requests.Session()
session.mount('http://', requests.adapters.HTTPAdapter(pool_connections=30, pool_maxsize=30, max_retries=3))
get_session.session = session
return get_session.session
class Login(object):
uselsess_headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Encoding': 'gzip,deflate,sdch',
'Accept-Language': 'zh-CN,en-US;q=0.8,en;q=0.6',
'Connection': 'keep-alive',
'Host': 'login.weibo.cn',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.152 Safari/537.36',
}
data = {
'mobile': USERNAME,
'remember': 'on',
'submit': '登录',
# 'password_8202': PASSWORD,
# 'backURL': 'http%3A%2F%2Fweibo.cn%2Flogin',
# 'backTitle': '新浪微博',
# 'tryCount': '',
# 'vk': '8202_653a_2216381998',
# 'code': 'kwlj',
# 'capId': '2_ccbdc8398cb418de',
}
# posturl = 'http://login.weibo.cn/login/?rand=1759580283&backURL=http%3A%2F%2Fweibo.cn&backTitle=%E6%89%8B%E6%9C%BA%E6%96%B0%E6%B5%AA%E7%BD%91&vt=4'
def __init__(self):
self._login = None
self.loginurl = 'http://login.weibo.cn/login/'
self.session = get_session()
def login(self):
"""
data `password_??` and `vk??` need update as time goes by.
So, we get them in login page and post them all.
`rand` in `posturl` also in login page's `form action`, but it is not important.
"""
back = self.session.get(self.loginurl)
html = lxml.html.fromstring(back.content)
password = html.cssselect('.c form input[type=password]')[0].get('name')
for i in html.cssselect('.c form input[type=hidden]'):
self.data[i.get('name')] = i.get('value')
self.data[password] = PASSWORD
posturl = self.loginurl + html.cssselect('.c form[method=post]')[0].get('action')
print('http://weibo.cn/interface/f/ttt/captcha/show.php?cpt={}'.format(self.data['capId']))
self.data['code'] = raw_input('input captcha code: ')
self.session.post(posturl, data=self.data)
self._login = True
def get_login_session(self):
if self._login != True:
self.login()
return self.session
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: Yuande Liu <miracle (at) gmail.com>
from settings import USERNAME, PASSWORD
import requests
import lxml.html
requests.adapters.DEFAULT_RETRIES = 3
def get_session():
""".. :py:method::
"""
if not hasattr(get_session, 'session'):
session = requests.Session()
session.mount('http://', requests.adapters.HTTPAdapter(pool_connections=30, pool_maxsize=30, max_retries=3))
get_session.session = session
return get_session.session
class Login(object):
uselsess_headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
'Accept-Encoding': 'gzip,deflate,sdch',
'Accept-Language': 'zh-CN,en-US;q=0.8,en;q=0.6',
'Connection': 'keep-alive',
'Host': 'login.weibo.cn',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.152 Safari/537.36',
}
data = {
'mobile': USERNAME,
'remember': 'on',
'submit': '登录',
# 'password_8202': PASSWORD,
# 'backURL': 'http%3A%2F%2Fweibo.cn%2Flogin',
# 'backTitle': '新浪微博',
# 'tryCount': '',
# 'vk': '8202_653a_2216381998',
# 'code': 'kwlj',
# 'capId': '2_ccbdc8398cb418de',
}
posturl = 'http://login.weibo.cn/login/?rand=1759580283&backURL=http%3A%2F%2Fweibo.cn&backTitle=%E6%89%8B%E6%9C%BA%E6%96%B0%E6%B5%AA%E7%BD%91&vt=4'
def __init__(self):
self._login = None
self.loginurl = 'http://login.weibo.cn/login/'
self.session = get_session()
def login(self):
"""
data `password_??` and `vk??` need update as time goes by.
So, we get them in login page and post them all.
`rand` in `posturl` also in login page's `form action`, but it is not important.
"""
back = self.session.get(self.loginurl)
html = lxml.html.fromstring(back.content)
password = html.cssselect('.c form input[type=password]')[0].get('name')
for i in html.cssselect('.c form input[type=hidden]'):
self.data[i.get('name')] = i.get('value')
self.data[password] = PASSWORD
self.session.post(self.posturl, data=self.data)
self._login = True
def get_login_session(self):
if self._login != True:
self.login()
return self.session
| Python | 0.000002 |
d45a0d97b978c18bb0a40e4cec6d3dab6ec2d566 | fix loading crystal.json | test/command_line/tst_refine.py | test/command_line/tst_refine.py | #!/usr/bin/env cctbx.python
#
# Copyright (C) (2013) STFC Rutherford Appleton Laboratory, UK.
#
# Author: David Waterman.
#
# This code is distributed under the BSD license, a copy of which is
# included in the root directory of this package.
#
"""
Test command line program dials.refine by running a job with saved data and
comparing with expected output.
This serves as a high level test that not only checks whether refinement works,
but also that the command line program is functioning and that the output models
have not changed format and so on.
"""
# python imports
from __future__ import division
import os
import libtbx.load_env # required for libtbx.env.find_in_repositories
from libtbx import easy_run
from libtbx.test_utils import approx_equal
from libtbx.test_utils import open_tmp_directory
def test1():
dials_regression = libtbx.env.find_in_repositories(
relative_path="dials_regression",
test=os.path.isdir)
# use the i04_weak_data for this test
data_dir = os.path.join(dials_regression, "refinement_test_data", "i04_weak_data")
sweep_path = os.path.join(data_dir, "sweep.json")
crystal_path = os.path.join(data_dir, "crystal.json")
pickle_path = os.path.join(data_dir, "indexed_strong.pickle")
for pth in ():
assert os.path.exists(pth)
cmd = "dials.refine " + sweep_path + " " + crystal_path + " " + pickle_path
# work in a temporary directory
cwd = os.path.abspath(os.curdir)
tmp_dir = open_tmp_directory(suffix="test_dials_refine")
os.chdir(tmp_dir)
result = easy_run.fully_buffered(command=cmd).raise_if_errors()
os.chdir(cwd)
# load results
from dials.model.serialize import load
from cctbx.crystal.crystal_model.serialize import load_crystal
reg_sweep = load.sweep(os.path.join(data_dir, "regression_sweep.json"))
reg_crystal = load_crystal(os.path.join(data_dir, "regression_crystal.json"))
sweep = load.sweep(os.path.join(tmp_dir, "refined_sweep.json"))
crystal = load_crystal(os.path.join(tmp_dir, "refined_crystal.json"))
# test refined models against expected
assert crystal == reg_crystal
assert sweep.get_detector() == reg_sweep.get_detector()
assert sweep.get_beam() == reg_sweep.get_beam()
print "OK"
return
def run():
if not libtbx.env.has_module("dials_regression"):
print "Skipping tests in " + __file__ + " as dials_regression not present"
return
test1()
if __name__ == '__main__':
import sys
from libtbx.utils import show_times_at_exit
show_times_at_exit()
run()
| #!/usr/bin/env cctbx.python
#
# Copyright (C) (2013) STFC Rutherford Appleton Laboratory, UK.
#
# Author: David Waterman.
#
# This code is distributed under the BSD license, a copy of which is
# included in the root directory of this package.
#
"""
Test command line program dials.refine by running a job with saved data and
comparing with expected output.
This serves as a high level test that not only checks whether refinement works,
but also that the command line program is functioning and that the output models
have not changed format and so on.
"""
# python imports
from __future__ import division
import os
import libtbx.load_env # required for libtbx.env.find_in_repositories
from libtbx import easy_run
from libtbx.test_utils import approx_equal
from libtbx.test_utils import open_tmp_directory
def test1():
dials_regression = libtbx.env.find_in_repositories(
relative_path="dials_regression",
test=os.path.isdir)
# use the i04_weak_data for this test
data_dir = os.path.join(dials_regression, "refinement_test_data", "i04_weak_data")
sweep_path = os.path.join(data_dir, "sweep.json")
crystal_path = os.path.join(data_dir, "crystal.json")
pickle_path = os.path.join(data_dir, "indexed_strong.pickle")
for pth in ():
assert os.path.exists(pth)
cmd = "dials.refine " + sweep_path + " " + crystal_path + " " + pickle_path
# work in a temporary directory
cwd = os.path.abspath(os.curdir)
tmp_dir = open_tmp_directory(suffix="test_dials_refine")
os.chdir(tmp_dir)
result = easy_run.fully_buffered(command=cmd).raise_if_errors()
os.chdir(cwd)
# load results
from dials.model.serialize import load
reg_sweep = load.sweep(os.path.join(data_dir, "regression_sweep.json"))
reg_crystal = load.crystal(os.path.join(data_dir, "regression_crystal.json"))
sweep = load.sweep(os.path.join(tmp_dir, "refined_sweep.json"))
crystal = load.crystal(os.path.join(tmp_dir, "refined_crystal.json"))
# test refined models against expected
assert crystal == reg_crystal
assert sweep.get_detector() == reg_sweep.get_detector()
assert sweep.get_beam() == reg_sweep.get_beam()
print "OK"
return
def run():
if not libtbx.env.has_module("dials_regression"):
print "Skipping tests in " + __file__ + " as dials_regression not present"
return
test1()
if __name__ == '__main__':
import sys
from libtbx.utils import show_times_at_exit
show_times_at_exit()
run()
| Python | 0.000001 |
eca33ec2a4307009b049e001e49329496bb0ce93 | Update test_ethiopia.py | test/countries/test_ethiopia.py | test/countries/test_ethiopia.py | # -*- coding: utf-8 -*-
# python-holidays
# ---------------
# A fast, efficient Python library for generating country, province and state
# specific sets of holidays on the fly. It aims to make determining whether a
# specific date is a holiday as fast and flexible as possible.
#
# Author: ryanss <ryanssdev@icloud.com> (c) 2014-2017
# dr-prodigy <maurizio.montel@gmail.com> (c) 2017-2021
# Website: https://github.com/dr-prodigy/python-holidays
# License: MIT (see LICENSE file)
import sys
import unittest
from datetime import date
import holidays
class TestEthiopia(unittest.TestCase):
def setUp(self):
self.holidays = holidays.ET()
def test_2019(self):
self.assertIn(date(2019, 1, 7), self.holidays)
self.assertIn(date(2019, 1, 19), self.holidays)
self.assertIn(date(2019, 3, 2), self.holidays)
self.assertIn(date(2019, 4, 28), self.holidays)
self.assertIn(date(2019, 4, 26), self.holidays)
self.assertIn(date(2019, 5, 1), self.holidays)
self.assertIn(date(2019, 5, 28), self.holidays)
self.assertIn(date(2019, 9, 12), self.holidays)
self.assertIn(date(2019, 9, 28), self.holidays)
self.assertIn(date(2019, 11, 10), self.holidays)
def test_ethiopian_christmas(self):
self.assertIn(date(2019, 1, 7), self.holidays)
def test_labour_day(self):
self.assertIn(date(2019, 5, 1), self.holidays)
def test_hijri_based(self):
if sys.version_info >= (3, 6):
import importlib.util
if importlib.util.find_spec("hijri_converter"):
self.holidays = holidays.EG(years=[2010])
self.assertIn(date(2019, 6, 5), self.holidays)
self.assertIn(date(2019, 8, 11), self.holidays)
self.assertIn(date(2019, 11, 9), self.holidays)
# eid_alfitr
self.assertIn(date(2019, 6, 4), self.holidays)
# eid_aladha
self.assertIn(date(2019, 8, 11), self.holidays)
# eid_elfetr_2010
self.assertIn(date(2010, 11, 15), self.holidays)
# muhammad's birthday
self.assertIn(date(2010, 2, 26), self.holidays)
| # -*- coding: utf-8 -*-
# python-holidays
# ---------------
# A fast, efficient Python library for generating country, province and state
# specific sets of holidays on the fly. It aims to make determining whether a
# specific date is a holiday as fast and flexible as possible.
#
# Author: ryanss <ryanssdev@icloud.com> (c) 2014-2017
# dr-prodigy <maurizio.montel@gmail.com> (c) 2017-2021
# Website: https://github.com/dr-prodigy/python-holidays
# License: MIT (see LICENSE file)
import sys
import unittest
from datetime import date
import holidays
class TestEthiopia(unittest.TestCase):
def setUp(self):
self.holidays = holidays.ET()
def test_2019(self):
self.assertIn(date(2019, 1, 7), self.holidays)
self.assertIn(date(2019, 1, 19), self.holidays)
self.assertIn(date(2019, 3, 2), self.holidays)
self.assertIn(date(2019, 4, 28), self.holidays)
self.assertIn(date(2019, 4, 26), self.holidays)
self.assertIn(date(2019, 5, 1), self.holidays)
self.assertIn(date(2019, 5, 28), self.holidays)
self.assertIn(date(2019, 9, 12), self.holidays)
self.assertIn(date(2019, 9, 28), self.holidays)
self.assertIn(date(2019, 11, 10), self.holidays)
def test_ethiopian_christmas(self):
self.assertIn(date(2019, 1, 7), self.holidays)
def test_labour_day(self):
self.assertIn(date(2019, 5, 1), self.holidays)
def test_hijri_based(self):
if sys.version_info >= (3, 6):
import importlib.util
if importlib.util.find_spec("hijri_converter"):
self.holidays = holidays.EG(years=[2010])
self.assertIn(date(2019, 6, 5), self.holidays
self.assertIn(date(2019, 8, 11), self.holidays)
self.assertIn(date(2019, 11, 9), self.holidays)
# eid_alfitr
self.assertIn(date(2019, 6, 4), self.holidays)
# eid_aladha
self.assertIn(date(2019, 8, 11), self.holidays)
# eid_elfetr_2010
self.assertIn(date(2010, 11, 15), self.holidays)
# muhammad's birthday
self.assertIn(date(2010, 2, 26), self.holidays)
| Python | 0.000001 |
e318497949a340b3b821efbc4492c8605441fa47 | reformat code | flask_praetorian/constants.py | flask_praetorian/constants.py | import pendulum
import enum
from os.path import dirname, abspath
DEFAULT_JWT_PLACES = ['header', 'cookie']
DEFAULT_JWT_COOKIE_NAME = 'access_token'
DEFAULT_JWT_HEADER_NAME = 'Authorization'
DEFAULT_JWT_HEADER_TYPE = 'Bearer'
DEFAULT_JWT_ACCESS_LIFESPAN = pendulum.duration(minutes=15)
DEFAULT_JWT_REFRESH_LIFESPAN = pendulum.duration(days=30)
DEFAULT_JWT_RESET_LIFESPAN = pendulum.duration(minutes=10)
DEFAULT_JWT_ALGORITHM = 'HS256'
DEFAULT_JWT_ALLOWED_ALGORITHMS = ['HS256']
DEFAULT_USER_CLASS_VALIDATION_METHOD = 'is_valid'
DEFAULT_CONFIRMATION_TEMPLATE = (
"{}/flask_praetorian/templates/registration_email.html".format(
dirname(dirname(abspath(__file__))),
)
)
DEFAULT_CONFIRMATION_SENDER = 'you@whatever.com'
DEFAULT_CONFIRMATION_SUBJECT = 'Please confirm your registration'
DEFAULT_RESET_TEMPLATE = (
"{}/flask_praetorian/templates/reset_email.html".format(
dirname(dirname(abspath(__file__))),
)
)
DEFAULT_RESET_SENDER = 'you@whatever.com'
DEFAULT_RESET_SUBJECT = 'Password Reset Requested'
DEFAULT_HASH_AUTOUPDATE = False
DEFAULT_HASH_AUTOTEST = False
DEFAULT_HASH_SCHEME = 'pbkdf2_sha512'
DEFAULT_HASH_ALLOWED_SCHEMES = [
'pbkdf2_sha512', 'sha256_crypt', 'sha512_crypt', 'bcrypt', 'argon2',
'bcrypt_sha256',
]
DEFAULT_HASH_DEPRECATED_SCHEMES = []
REFRESH_EXPIRATION_CLAIM = 'rf_exp'
IS_REGISTRATION_TOKEN_CLAIM = 'is_ert'
IS_RESET_TOKEN_CLAIM = 'is_prt'
RESERVED_CLAIMS = {
'iat', 'exp', 'jti', 'id', 'rls',
REFRESH_EXPIRATION_CLAIM,
IS_REGISTRATION_TOKEN_CLAIM,
IS_RESET_TOKEN_CLAIM,
}
# 1M days seems reasonable. If this code is being used in 3000 years...welp
VITAM_AETERNUM = pendulum.Duration(days=1000000)
class AccessType(enum.Enum):
access = 'ACCESS'
refresh = 'REFRESH'
register = 'REGISTER'
reset = 'RESET'
| import pendulum
import enum
from os.path import dirname, abspath
DEFAULT_JWT_PLACES = [
'header', 'cookie'
]
DEFAULT_JWT_COOKIE_NAME = 'access_token'
DEFAULT_JWT_HEADER_NAME = 'Authorization'
DEFAULT_JWT_HEADER_TYPE = 'Bearer'
DEFAULT_JWT_ACCESS_LIFESPAN = pendulum.duration(minutes=15)
DEFAULT_JWT_REFRESH_LIFESPAN = pendulum.duration(days=30)
DEFAULT_JWT_RESET_LIFESPAN = pendulum.duration(minutes=10)
DEFAULT_JWT_ALGORITHM = 'HS256'
DEFAULT_JWT_ALLOWED_ALGORITHMS = ['HS256']
DEFAULT_USER_CLASS_VALIDATION_METHOD = 'is_valid'
DEFAULT_CONFIRMATION_TEMPLATE = (
"{}/flask_praetorian/templates/registration_email.html".format(
dirname(dirname(abspath(__file__))),
)
)
DEFAULT_CONFIRMATION_SENDER = 'you@whatever.com'
DEFAULT_CONFIRMATION_SUBJECT = 'Please confirm your registration'
DEFAULT_RESET_TEMPLATE = (
"{}/flask_praetorian/templates/reset_email.html".format(
dirname(dirname(abspath(__file__))),
)
)
DEFAULT_RESET_SENDER = 'you@whatever.com'
DEFAULT_RESET_SUBJECT = 'Password Reset Requested'
DEFAULT_HASH_AUTOUPDATE = False
DEFAULT_HASH_AUTOTEST = False
DEFAULT_HASH_SCHEME = 'pbkdf2_sha512'
DEFAULT_HASH_ALLOWED_SCHEMES = [
'pbkdf2_sha512', 'sha256_crypt', 'sha512_crypt', 'bcrypt', 'argon2',
'bcrypt_sha256',
]
DEFAULT_HASH_DEPRECATED_SCHEMES = []
REFRESH_EXPIRATION_CLAIM = 'rf_exp'
IS_REGISTRATION_TOKEN_CLAIM = 'is_ert'
IS_RESET_TOKEN_CLAIM = 'is_prt'
RESERVED_CLAIMS = {
'iat', 'exp', 'jti', 'id', 'rls',
REFRESH_EXPIRATION_CLAIM,
IS_REGISTRATION_TOKEN_CLAIM,
IS_RESET_TOKEN_CLAIM,
}
# 1M days seems reasonable. If this code is being used in 3000 years...welp
VITAM_AETERNUM = pendulum.Duration(days=1000000)
class AccessType(enum.Enum):
access = 'ACCESS'
refresh = 'REFRESH'
register = 'REGISTER'
reset = 'RESET'
| Python | 0.999729 |
3024d4628044a22d9fc1ec0032351d1da0d4ed1a | make code more concise and fix spelling | h5py/_hl/vds.py | h5py/_hl/vds.py | # This file is part of h5py, a Python interface to the HDF5 library.
#
# http://www.h5py.org
#
# Copyright 2008-2013 Andrew Collette and contributors
#
# License: Standard 3-clause BSD; see "license.txt" for full license terms
# and contributor agreement.
"""
High-level interface for creating HDF5 virtual datasets
"""
from copy import deepcopy as copy
from collections import namedtuple
from .selections import SimpleSelection
from .. import h5s, h5
from .. import version
class VDSmap(namedtuple('VDSmap', ('vspace', 'file_name',
'dset_name', 'src_space'))):
'''Defines a region in a virtual dataset mapping to part of a source dataset
'''
vds_support = False
hdf5_version = version.hdf5_version_tuple[0:3]
if hdf5_version >= h5.get_config().vds_min_hdf5_version:
vds_support = True
class VirtualSource(object):
"""Source definition for virtual data sets.
Instantiate this class to represent an entire source dataset, and then
slice it to indicate which regions should be used in the virtual dataset.
path_or_dataset
The path to a file, or an h5py dataset. If a dataset is given,
the other parameters are ignored, and the relevant values taken from
the dataset instead.
name
The name of the source dataset within the file.
shape
A tuple giving the shape of the dataset.
dtype
Numpy dtype or string.
maxshape
The source dataset is resizable up to this shape. Use None for
axes you want to be unlimited.
"""
def __init__(self, path_or_dataset, name=None,
shape=None, dtype=None, maxshape=None):
from .dataset import Dataset
if isinstance(path_or_dataset, Dataset):
failed = {k: v
for k, v in
{'name': name, 'shape': shape,
'dtype': dtype, 'maxshape': maxshape}.items()
if v is not None}
if failed:
raise TypeError("If a Dataset is passed as the first argument "
"then no other arguments may be passed. You "
"passed {failed}".format(failed=failed))
ds = path_or_dataset
path = ds.file.filename
name = ds.name
shape = ds.shape
dtype = ds.dtype
maxshape = ds.maxshape
else:
path = path_or_dataset
if name is None:
raise TypeError("The name parameter is required when "
"specifying a source by path")
if shape is None:
raise TypeError("The shape parameter is required when "
"specifying a source by path")
self.path = path
self.name = name
self.dtype = dtype
if maxshape is None:
self.maxshape = shape
else:
self.maxshape = tuple([h5s.UNLIMITED if ix is None else ix
for ix in maxshape])
self.sel = SimpleSelection(shape)
@property
def shape(self):
return self.sel.mshape
def __getitem__(self, key):
tmp = copy(self)
tmp.sel = SimpleSelection(self.shape)[key]
return tmp
class VirtualLayout(object):
"""Object for building a virtual dataset.
Instantiate this class to define a virtual dataset, assign to slices of it
(using VirtualSource objects), and then pass it to
group.create_virtual_dataset() to add the virtual dataset to a file.
This class does not allow access to the data; the virtual dataset must
be created in a file before it can be used.
shape
A tuple giving the shape of the dataset.
dtype
Numpy dtype or string.
maxshape
The source dataset is resizable up to this shape. Use None for
axes you want to be unlimited.
"""
def __init__(self, shape, dtype=None, maxshape=None):
self.shape = shape
self.dtype = dtype
self.maxshape = maxshape
self.sources = []
def __setitem__(self, key, source):
sel = SimpleSelection(self.shape)[key]
self.sources.append(VDSmap(sel.id,
source.path,
source.name,
source.sel.id))
| # This file is part of h5py, a Python interface to the HDF5 library.
#
# http://www.h5py.org
#
# Copyright 2008-2013 Andrew Collette and contributors
#
# License: Standard 3-clause BSD; see "license.txt" for full license terms
# and contributor agreement.
"""
High-level interface for creating HDF5 virtual datasets
"""
from copy import deepcopy as copy
from collections import namedtuple
from .selections import SimpleSelection
from .. import h5s, h5
from .. import version
class VDSmap(namedtuple('VDSmap', ('vspace', 'file_name',
'dset_name', 'src_space'))):
'''Defines a region in a virtual dataset mapping to part of a source dataset
'''
vds_support = False
hdf5_version = version.hdf5_version_tuple[0:3]
if hdf5_version >= h5.get_config().vds_min_hdf5_version:
vds_support = True
class VirtualSource(object):
"""Source definition for virtual data sets.
Instantiate this class to represent an entire source dataset, and then
slice it to indicate which regions should be used in the virtual dataset.
path_or_dataset
The path to a file, or an h5py dataset. If a dataset is given,
the other parameters are ignored, and the relevant values taken from
the dataset instead.
name
The name of the source dataset within the file.
shape
A tuple giving the shape of the dataset.
dtype
Numpy dtype or string.
maxshape
The source dataset is resizable up to this shape. Use None for
axes you want to be unlimited.
"""
def __init__(self, path_or_dataset, name=None,
shape=None, dtype=None, maxshape=None):
from .dataset import Dataset
if isinstance(path_or_dataset, Dataset):
if any(inp is not None
for inp in [name, shape, dtype, maxshape]):
failed = {k: v
for k, v in
{'name': name, 'shape': shape,
'dtype': dtype, 'maxshape': maxshape}.items()
if v is not None}
raise TypeError("If a Dataset is passed as the first argument "
"then no other arguments maybe passed. You "
"passed {failed}".format(failed=failed))
ds = path_or_dataset
path = ds.file.filename
name = ds.name
shape = ds.shape
dtype = ds.dtype
maxshape = ds.maxshape
else:
path = path_or_dataset
if name is None:
raise TypeError("The name parameter is required when "
"specifying a source by path")
if shape is None:
raise TypeError("The shape parameter is required when "
"specifying a source by path")
self.path = path
self.name = name
self.dtype = dtype
if maxshape is None:
self.maxshape = shape
else:
self.maxshape = tuple([h5s.UNLIMITED if ix is None else ix
for ix in maxshape])
self.sel = SimpleSelection(shape)
@property
def shape(self):
return self.sel.mshape
def __getitem__(self, key):
tmp = copy(self)
tmp.sel = SimpleSelection(self.shape)[key]
return tmp
class VirtualLayout(object):
"""Object for building a virtual dataset.
Instantiate this class to define a virtual dataset, assign to slices of it
(using VirtualSource objects), and then pass it to
group.create_virtual_dataset() to add the virtual dataset to a file.
This class does not allow access to the data; the virtual dataset must
be created in a file before it can be used.
shape
A tuple giving the shape of the dataset.
dtype
Numpy dtype or string.
maxshape
The source dataset is resizable up to this shape. Use None for
axes you want to be unlimited.
"""
def __init__(self, shape, dtype=None, maxshape=None):
self.shape = shape
self.dtype = dtype
self.maxshape = maxshape
self.sources = []
def __setitem__(self, key, source):
sel = SimpleSelection(self.shape)[key]
self.sources.append(VDSmap(sel.id,
source.path,
source.name,
source.sel.id))
| Python | 0.000123 |
6410dd998d8b65674941b3f4d217d27a8084ec25 | fix commit getter | hal/cvs/gits.py | hal/cvs/gits.py | #!/usr/bin/env python
# coding: utf-8
""" Handles main models in git repository """
from git import Repo
from unidiff import PatchSet
from hal.cvs.versioning import Version
class Diff:
""" Git diff result """
ADD = 'added'
DEL = 'removed'
def __init__(self, diff):
"""
:param diff: git.Diff
Diff between 2 commits
"""
self.d = diff
def __str__(self):
totals = self.get_totals()
return "+", totals[self.ADD], " -", totals[self.DEL]
def get_totals(self):
"""
:return: {}
Dictionary with total additions and deletions
"""
total_added = 0
total_removed = 0
patch = PatchSet(self.d)
total_added += sum([
edit.added for edit in patch
])
total_removed += sum([
edit.removed for edit in patch
])
return {
self.ADD: total_added,
self.DEL: total_removed
}
class Commit:
""" Git repository commit """
def __init__(self, commit):
"""
:param commit: git.Commit
Commit of repository
"""
self.c = commit
def __str__(self, date_format="%H:%M:%S %y-%m-%d %z"):
"""
:param date_format: str
Format date and time with this format
:return: str
Pretty description of commit
"""
hash_value = self.c.hexsha
date_time = self.c.authored_datetime.strftime(date_format)
return "(" + hash_value + ") at " + date_time
def get_author(self):
author = self.c.author
out = ""
if author.name is not None:
out += author.name
if author.email is not None:
out += " (" + author.email + ")"
return out
class Repository:
""" Git repository """
def __init__(self, repo_path):
"""
:param repo_path: str
Path to repository
"""
self.r = Repo(repo_path)
def get_last_commit(self):
"""
:return: git.Commit
Last commit of repository
"""
return self.r.head.commit
def get_diff_amounts(self):
"""
:return: []
List of total diff between 2 consecutive commits since start
"""
diffs = []
last_commit = None
for commit in self.r.iter_commits():
if last_commit is not None:
diff = self.get_diff(commit, last_commit)
total_changed = diff[Diff.ADD] + diff[Diff.DEL]
diffs.append(total_changed)
last_commit = commit
return diffs
def get_diff(self, commit, other_commit):
"""
:param commit: git.Commit
First commit
:param other_commit: git.Commit
Second commit
:return: {}
Dictionary with total additions and deletions
"""
diff = self.r.git.diff(commit.hexsha, other_commit.hexsha)
return Diff(diff).get_totals()
def get_version(self):
"""
:return: Version
Version of this code, based on commits diffs
"""
diffs = self.get_diff_amounts()
diff_to_increase_ratio = 1 / 100
version = Version()
for diff in diffs:
version.increase_by_changes(diff, diff_to_increase_ratio)
return version
def get_pretty_version(self):
"""
:return: str
Pretty version of this repository
"""
version = self.get_version()
last = self.get_last_commit()
return str(version) + " " + str(Commit(last))
| #!/usr/bin/env python
# coding: utf-8
""" Handles main models in git repository """
from git import Repo
from unidiff import PatchSet
from hal.cvs.versioning import Version
class Diff:
""" Git diff result """
ADD = 'added'
DEL = 'removed'
def __init__(self, diff):
"""
:param diff: git.Diff
Diff between 2 commits
"""
self.d = diff
def __str__(self):
totals = self.get_totals()
return "+", totals[self.ADD], " -", totals[self.DEL]
def get_totals(self):
"""
:return: {}
Dictionary with total additions and deletions
"""
total_added = 0
total_removed = 0
patch = PatchSet(self.d)
total_added += sum([
edit.added for edit in patch
])
total_removed += sum([
edit.removed for edit in patch
])
return {
self.ADD: total_added,
self.DEL: total_removed
}
class Commit:
""" Git repository commit """
def __init__(self, commit):
"""
:param commit: git.Commit
Commit of repository
"""
self.c = commit
def __str__(self, date_format="%H:%M:%S %y-%m-%d %z"):
"""
:param date_format: str
Format date and time with this format
:return: str
Pretty description of commit
"""
hash_value = self.c.hexsha
date_time = self.c.authored_datetime.strftime(date_format)
return "(" + hash_value + ") at " + date_time
def get_author(self):
author = self.c.author
out = ""
if author.name is not None:
out += author.name
if author.email is not None:
out += " (" + author.email + ")"
return out
class Repository:
""" Git repository """
def __init__(self, repo_path):
"""
:param repo_path: str
Path to repository
"""
self.r = Repo(repo_path)
def get_last_commit(self):
"""
:return: git.Commit
Last commit of repository
"""
return self.r.head.commit
def get_diff_amounts(self):
"""
:return: []
List of total diff between 2 consecutive commits since start
"""
diffs = []
last_commit = None
for commit in self.r.iter_commits():
if last_commit is not None:
diff = self.get_diff(commit, last_commit)
total_changed = diff[Diff.ADD] + diff[Diff.DEL]
diffs.append(total_changed)
return diffs
def get_diff(self, commit, other_commit):
"""
:param commit: git.Commit
First commit
:param other_commit: git.Commit
Second commit
:return: {}
Dictionary with total additions and deletions
"""
diff = self.r.git.diff(commit.hexsha, other_commit.hexsha)
return Diff(diff).get_totals()
def get_version(self):
"""
:return: Version
Version of this code, based on commits diffs
"""
diffs = self.get_diff_amounts()
diff_to_increase_ratio = 1 / 100
version = Version()
for diff in diffs:
version.increase_by_changes(diff, diff_to_increase_ratio)
return version
def get_pretty_version(self):
"""
:return: str
Pretty version of this repository
"""
version = self.get_version()
last = self.get_last_commit()
return str(version) + " " + str(last)
| Python | 0.000001 |
0ff88a6f75072b8bed822799b5ecf5b4d3412c66 | fix params | firebase/__init__.py | firebase/__init__.py | import requests
import urlparse #for urlparse and urljoin
import os #for os.path.dirname
import json #for dumps
class Firebase():
ROOT_URL = '' #no trailing slash
def __init__(self, root_url, auth_token=None):
self.ROOT_URL = root_url.rstrip('/')
self.auth_token = auth_token
#These methods are intended to mimic Firebase API calls.
def child(self, path):
root_url = '%s/' % self.ROOT_URL
url = urlparse.urljoin(root_url, path.lstrip('/'))
return Firebase(url)
def parent(self):
url = os.path.dirname(self.ROOT_URL)
#If url is the root of your Firebase, return None
up = urlparse.urlparse(url)
if up.path == '':
return None #maybe throw exception here?
return Firebase(url)
def name(self):
return os.path.basename(self.ROOT_URL)
def toString(self):
return self.__str__()
def __str__(self):
return self.ROOT_URL
def set(self, value):
return self.put(value)
def push(self, data):
return self.post(data)
def update(self, data):
return self.patch(data)
def remove(self):
return self.delete()
#These mirror REST API functionality
def put(self, data):
return self.__request('put', data = data)
def patch(self, data):
return self.__request('patch', data = data)
def get(self):
return self.__request('get')
#POST differs from PUT in that it is equivalent to doing a 'push()' in
#Firebase where a new child location with unique name is generated and
#returned
def post(self, data):
return self.__request('post', data = data)
def delete(self):
return self.__request('delete')
#Private
def __request(self, method, **kwargs):
#Firebase API does not accept form-encoded PUT/POST data. It needs to
#be JSON encoded.
if 'data' in kwargs:
kwargs['data'] = json.dumps(kwargs['data'])
params = {}
if self.auth_token:
if 'params' in kwargs:
params = kwargs['params']
del kwargs['params']
params.update({'auth': self.auth_token})
r = requests.request(method, self.__url(), params=params, **kwargs)
r.raise_for_status() #throw exception if error
return r.json
def __url(self):
#We append .json to end of ROOT_URL for REST API.
return '%s.json' % self.ROOT_URL
| import requests
import urlparse #for urlparse and urljoin
import os #for os.path.dirname
import json #for dumps
class Firebase():
ROOT_URL = '' #no trailing slash
def __init__(self, root_url, auth_token=None):
self.ROOT_URL = root_url.rstrip('/')
self.auth_token = auth_token
#These methods are intended to mimic Firebase API calls.
def child(self, path):
root_url = '%s/' % self.ROOT_URL
url = urlparse.urljoin(root_url, path.lstrip('/'))
return Firebase(url)
def parent(self):
url = os.path.dirname(self.ROOT_URL)
#If url is the root of your Firebase, return None
up = urlparse.urlparse(url)
if up.path == '':
return None #maybe throw exception here?
return Firebase(url)
def name(self):
return os.path.basename(self.ROOT_URL)
def toString(self):
return self.__str__()
def __str__(self):
return self.ROOT_URL
def set(self, value):
return self.put(value)
def push(self, data):
return self.post(data)
def update(self, data):
return self.patch(data)
def remove(self):
return self.delete()
#These mirror REST API functionality
def put(self, data):
return self.__request('put', data = data)
def patch(self, data):
return self.__request('patch', data = data)
def get(self):
return self.__request('get')
#POST differs from PUT in that it is equivalent to doing a 'push()' in
#Firebase where a new child location with unique name is generated and
#returned
def post(self, data):
return self.__request('post', data = data)
def delete(self):
return self.__request('delete')
#Private
def __request(self, method, **kwargs):
#Firebase API does not accept form-encoded PUT/POST data. It needs to
#be JSON encoded.
if 'data' in kwargs:
kwargs['data'] = json.dumps(kwargs['data'])
if self.auth_token:
kwargs['auth'] = self.auth_token
r = requests.request(method, self.__url(), **kwargs)
r.raise_for_status() #throw exception if error
return r.json
def __url(self):
#We append .json to end of ROOT_URL for REST API.
return '%s.json' % self.ROOT_URL
| Python | 0.000004 |
3109bd9a1d01e926e4fce3373db93db8a2d091e0 | Update 4.8_subtree.py | CrackingCodingInterview/4.8_subtree.py | CrackingCodingInterview/4.8_subtree.py | """
is a a subtree of b
both are bst
"""
class Node:
02
...
03
def compare_trees(self, node):
04
"""
05
Compare 2 trees
06
07
@param node tree's root node to compare to
08
@returns True if the tree passed is identical to this tree
09
"""
def compare_trees(self, node):
if node is None:
return False
if self.data != node.data:
return False
res = True
if self.left is None:
if node.left:
return False
else:
res = self.left.compare_trees(node.left)
if res is False:
return False
if self.right is None:
if node.right:
return False
else:
res = self.right.compare_trees(node.right)
return res
| """
is a a subtree of b
both are bst
"""
| Python | 0 |
42cefe67849fd97c52210ba750077238d938fe6a | Fix TZ issue in order_by_score | drum/links/utils.py | drum/links/utils.py | from __future__ import division, unicode_literals
from re import sub, split
from django.conf import settings
from django.utils.timezone import now
def order_by_score(queryset, score_fields, date_field, reverse=True):
"""
Take some queryset (links or comments) and order them by score,
which is basically "rating_sum / age_in_seconds ^ scale", where
scale is a constant that can be used to control how quickly scores
reduce over time. To perform this in the database, it needs to
support a POW function, which Postgres and MySQL do. For databases
that don't such as SQLite, we perform the scoring/sorting in
memory, which will suffice for development.
"""
scale = getattr(settings, "SCORE_SCALE_FACTOR", 2)
# Timestamp SQL function snippets mapped to DB backends.
# Defining these assumes the SQL functions POW() and NOW()
# are available for the DB backend.
timestamp_sqls = {
"mysql": "UNIX_TIMESTAMP(%s)",
"postgresql_psycopg2": "EXTRACT(EPOCH FROM %s)" ,
}
now_tz_sqls = {
"mysql": "UTC_TIMESTAMP()",
"postgresql_psycopg2": "NOW() AT TIME ZONE 'utc'",
}
db_engine = settings.DATABASES[queryset.db]["ENGINE"].rsplit(".", 1)[1]
timestamp_sql = timestamp_sqls.get(db_engine)
now_sql = now_tz_sqls.get(db_engine) if settings.USE_TZ else "NOW()",
if timestamp_sql and now_sql:
score_sql = "(%s) / POW(%s - %s, %s)" % (
" + ".join(score_fields),
timestamp_sql % now_sql,
timestamp_sql % date_field,
scale,
)
order_by = "-score" if reverse else "score"
return queryset.extra(select={"score": score_sql}).order_by(order_by)
else:
for obj in queryset:
age = (now() - getattr(obj, date_field)).total_seconds()
score_fields_sum = sum([getattr(obj, f) for f in score_fields])
score = score_fields_sum / pow(age, scale)
setattr(obj, "score", score)
return sorted(queryset, key=lambda obj: obj.score, reverse=reverse)
def auto_tag(link_obj):
"""
Split's the link object's title into words. Default function for the
``AUTO_TAG_FUNCTION`` setting.
"""
variations = lambda word: [word,
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9]|s)*$", "", word),
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9])*$", "", word)]
return sum(map(variations, split("\s|/", link_obj.title)), [])
| from __future__ import division, unicode_literals
from re import sub, split
from django.conf import settings
from django.utils.timezone import now
def order_by_score(queryset, score_fields, date_field, reverse=True):
"""
Take some queryset (links or comments) and order them by score,
which is basically "rating_sum / age_in_seconds ^ scale", where
scale is a constant that can be used to control how quickly scores
reduce over time. To perform this in the database, it needs to
support a POW function, which Postgres and MySQL do. For databases
that don't such as SQLite, we perform the scoring/sorting in
memory, which will suffice for development.
"""
scale = getattr(settings, "SCORE_SCALE_FACTOR", 2)
# Timestamp SQL function snippets mapped to DB backends.
# Defining these assumes the SQL functions POW() and NOW()
# are available for the DB backend.
timestamp_sqls = {
"mysql": "UNIX_TIMESTAMP(%s)",
"postgresql_psycopg2": "EXTRACT(EPOCH FROM %s)" ,
}
db_engine = settings.DATABASES[queryset.db]["ENGINE"].rsplit(".", 1)[1]
timestamp_sql = timestamp_sqls.get(db_engine)
if timestamp_sql:
score_sql = "(%s) / POW(%s - %s, %s)" % (
" + ".join(score_fields),
timestamp_sql % "NOW()",
timestamp_sql % date_field,
scale,
)
order_by = "-score" if reverse else "score"
return queryset.extra(select={"score": score_sql}).order_by(order_by)
else:
for obj in queryset:
age = (now() - getattr(obj, date_field)).total_seconds()
score_fields_sum = sum([getattr(obj, f) for f in score_fields])
score = score_fields_sum / pow(age, scale)
setattr(obj, "score", score)
return sorted(queryset, key=lambda obj: obj.score, reverse=reverse)
def auto_tag(link_obj):
"""
Split's the link object's title into words. Default function for the
``AUTO_TAG_FUNCTION`` setting.
"""
variations = lambda word: [word,
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9]|s)*$", "", word),
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9])*$", "", word)]
return sum(map(variations, split("\s|/", link_obj.title)), [])
| Python | 0 |
a38f2690ddcc72d24ab152b0c4c21ae51db7afa0 | Update evaluate_task.py | docker/evaluate_task.py | docker/evaluate_task.py | # 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
#
# https://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.
'''Evaluates a BIG-bench task in a docker container.
'''
import absl.flags
import absl.app
import os
import subprocess
MOUNT_PATH = '/bigbench'
RESULTS_DIR = 'eval_results'
# ----------------------------------------------------------------------------
FLAGS = absl.flags.FLAGS
absl.flags.DEFINE_string(
'task', None,
'Name of task to test. This should be the name of the task directory '
'under bigbench/benchmark_tasks.')
absl.flags.DEFINE_list('models', ['openai-gpt', 'gpt2'],
f'comma-separated list of models to evaluate')
absl.flags.DEFINE_string(
'output_path', None,
f'Path to output results. This path will be placed under your top-level '
f'BIG-bench repository directory under the directory "{RESULTS_DIR}". '
f'Thus if you specify --output_path=results.json, then the output file '
f'will be created at <top-level-dir>/eval_results/results.json. If not '
f'specified, this defaults to <task name>.json')
# ----------------------------------------------------------------------------
def main(_):
assert FLAGS.task is not None, 'task must be specified'
if FLAGS.output_path is None:
output_file = f'{FLAGS.task}.json'
else:
output_file = FLAGS.output_path.strip('/')
output_path = os.path.join(MOUNT_PATH, RESULTS_DIR, output_file)
host_path = os.path.abspath(os.path.split(os.path.split(__file__)[0])[0])
container_cmd = ' '.join([
f'cd {MOUNT_PATH} &&',
f'pip install . &&',
f'python /bigbench/bigbench/evaluate_task.py ',
f'--task',
FLAGS.task,
'--models',
','.join(FLAGS.models),
'--output_path',
output_path,
])
docker_cmd = [
'docker',
'run',
'-t',
'-v',
f'{host_path}:{MOUNT_PATH}',
'bigbench:latest',
'/usr/bin/bash',
'-c',
container_cmd,
]
subprocess.check_call(docker_cmd)
# ----------------------------------------------------------------------------
if __name__ == '__main__':
absl.app.run(main)
| # 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
#
# https://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.
'''Evaluates a task in BIG-bench docker container.
'''
import absl.flags
import absl.app
import os
import subprocess
MOUNT_PATH = '/bigbench'
RESULTS_DIR = 'eval_results'
# ----------------------------------------------------------------------------
FLAGS = absl.flags.FLAGS
absl.flags.DEFINE_string(
'task', None,
'Name of task to test. This should be the name of the task directory '
'under bigbench/benchmark_tasks.')
absl.flags.DEFINE_list('models', ['openai-gpt', 'gpt2'],
f'comma-separated list of models to evaluate')
absl.flags.DEFINE_string(
'output_path', None,
f'Path to output results. This path will be placed under your top-level '
f'BIG-bench repository directory under the directory "{RESULTS_DIR}". '
f'Thus if you specify --output_path=results.json, then the output file '
f'will be created at <top-level-dir>/eval_results/results.json. If not '
f'specified, this defaults to <task name>.json')
# ----------------------------------------------------------------------------
def main(_):
assert FLAGS.task is not None, 'task must be specified'
if FLAGS.output_path is None:
output_file = f'{FLAGS.task}.json'
else:
output_file = FLAGS.output_path.strip('/')
output_path = os.path.join(MOUNT_PATH, RESULTS_DIR, output_file)
host_path = os.path.abspath(os.path.split(os.path.split(__file__)[0])[0])
container_cmd = ' '.join([
f'cd {MOUNT_PATH} &&',
f'pip install . &&',
f'python /bigbench/bigbench/evaluate_task.py ',
f'--task',
FLAGS.task,
'--models',
','.join(FLAGS.models),
'--output_path',
output_path,
])
docker_cmd = [
'docker',
'run',
'-t',
'-v',
f'{host_path}:{MOUNT_PATH}',
'bigbench:latest',
'/usr/bin/bash',
'-c',
container_cmd,
]
subprocess.check_call(docker_cmd)
# ----------------------------------------------------------------------------
if __name__ == '__main__':
absl.app.run(main)
| Python | 0.000007 |
e675431d8d2930ae4a110feb94990a75308695cb | Change startup sequence | svr_record.py | svr_record.py | from tkinter import *
from pcf8591read import *
import threading
root = Tk()
def testytesty():
print ('oh look we used a callback')
# words from https://www.randomlists.com/random-words
# reader_worker = reader.run
class svr_interface():
def __init__(self):
self.current = 0
self.words = ['dusty','march','direful','complete','superb','poised','wait','quaint','save','copy','interest','separate','bright','utter','bored','nondescript','license','vest','dance','money','languid','swim','enthusiastic','quartz','planes','spiritual','imperfect','coal','hobbies','sound','bow','squirrel','push','treatment','mine','precede','weather','amazing','round','stingy','signal','marry','country','uncle','dust','certain','loose','knock','advice','confuse','animated','loving','feeling','absorbing','trick','spare','rod','caption','raspy','throne','clumsy','vague','tow','hang','rely','tired','barbarous','pan','innocent','combative','low','rub','mixed','actually','faulty','thirsty','dam','doubtful','flowers','defective','frogs','outstanding','ducks','icicle','fry','load','cracker','efficient','hop','fax','fancy','reading','real','addicted','motion','clean','unsuitable','race','aspiring','gold','check','bouncy','regret','chop','various','eminent','wander','living','equable','cluttered','geese','tightfisted','aftermath','quince','division','board','amuck','pretty','extra-large','sun','person','magical','invent','flap','stomach','black','river','town','type','stereotyped','paddle','expand','puncture','cakes','measly','kitty','courageous','shoe','number','third','ugliest','haircut','increase','wrathful','jog','straw','whisper','kick','talented','curious']
self.reader = adc_reader()
self.suffix = 0
self.current_word = self.words[self.current]
self.filename = self.current_word + '-' + str(self.suffix)
self.r_t = threading.Thread(target=self.reader.run,args=[self.filename])
self.r_t.daemon = True
self.r_t.start()
def key(event):
print ("pressed", repr(event.char))
# current_word = self.words[self.current]
# filename = current_word + '-' + str(suffix)
if event.char.isdigit():
suffix = event.char
print ('file series will take',suffix,'as suffix in filename')
if event.char==' ':
print('starting thread')
print(self.current_word)
self.reader.record = True
# Get the next word
# Start the recording for that word
# reader.run(filename)
# r_t.run([filename])
# If the recording is running:
if event.char=='s':
self.reader.record = False
# Stop the recording
self.current += 1
print('terminating thread',self.current)
# print('r_t:',vars(self.r_t),'r_t._target:',vars(self.r_t._target))
# Iterate the word
def callback(event):
frame.focus_set()
print ("clicked at", event.x, event.y)
frame = Frame(root, width=100, height=100)
frame.current = 0
frame.bind("<Key>", key)
frame.bind("<Button-1>", callback)
frame.pack()
root.mainloop()
s_inter = svr_interface()
| from tkinter import *
from pcf8591read import *
import threading
root = Tk()
def testytesty():
print ('oh look we used a callback')
# words from https://www.randomlists.com/random-words
# reader_worker = reader.run
class svr_interface():
def __init__(self):
self.current = 0
self.words = ['dusty','march','direful','complete','superb','poised','wait','quaint','save','copy','interest','separate','bright','utter','bored','nondescript','license','vest','dance','money','languid','swim','enthusiastic','quartz','planes','spiritual','imperfect','coal','hobbies','sound','bow','squirrel','push','treatment','mine','precede','weather','amazing','round','stingy','signal','marry','country','uncle','dust','certain','loose','knock','advice','confuse','animated','loving','feeling','absorbing','trick','spare','rod','caption','raspy','throne','clumsy','vague','tow','hang','rely','tired','barbarous','pan','innocent','combative','low','rub','mixed','actually','faulty','thirsty','dam','doubtful','flowers','defective','frogs','outstanding','ducks','icicle','fry','load','cracker','efficient','hop','fax','fancy','reading','real','addicted','motion','clean','unsuitable','race','aspiring','gold','check','bouncy','regret','chop','various','eminent','wander','living','equable','cluttered','geese','tightfisted','aftermath','quince','division','board','amuck','pretty','extra-large','sun','person','magical','invent','flap','stomach','black','river','town','type','stereotyped','paddle','expand','puncture','cakes','measly','kitty','courageous','shoe','number','third','ugliest','haircut','increase','wrathful','jog','straw','whisper','kick','talented','curious']
self.reader = adc_reader()
self.suffix = 0
self.current_word = self.words[self.current]
self.filename = self.current_word + '-' + str(self.suffix)
self.r_t = threading.Thread(target=self.reader.run,args=[self.filename])
self.r_t.daemon = True
def key(event):
print ("pressed", repr(event.char))
# current_word = self.words[self.current]
# filename = current_word + '-' + str(suffix)
if event.char.isdigit():
suffix = event.char
print ('file series will take',suffix,'as suffix in filename')
if event.char==' ':
print('starting thread')
print(self.current_word)
self.reader.record = True
# Get the next word
# Start the recording for that word
# reader.run(filename)
# r_t.run([filename])
# self.r_t.start()
# If the recording is running:
if event.char=='s':
self.reader.record = False
# Stop the recording
self.current += 1
print('terminating thread',self.current)
# print('r_t:',vars(self.r_t),'r_t._target:',vars(self.r_t._target))
# Iterate the word
def callback(event):
frame.focus_set()
print ("clicked at", event.x, event.y)
frame = Frame(root, width=100, height=100)
frame.current = 0
frame.bind("<Key>", key)
frame.bind("<Button-1>", callback)
frame.pack()
root.mainloop()
s_inter = svr_interface()
| Python | 0.000032 |
610915acda146b7a241403b38f2a85cd579ae7d9 | Update sliding-puzzle.py | Python/sliding-puzzle.py | Python/sliding-puzzle.py | # Time: O((m * n) * (m * n)!)
# Space: O((m * n) * (m * n)!)
# A* Search Algorithm
class Solution(object):
def slidingPuzzle(self, board):
"""
:type board: List[List[int]]
:rtype: int
"""
def dot(p1, p2):
return p1[0]*p2[0]+p1[1]*p2[1]
def heuristic_estimate(board, R, C, expected):
result = 0
for i in xrange(R):
for j in xrange(C):
val = board[C*i + j]
if val == 0: continue
r, c = expected[val]
result += abs(r-i) + abs(c-j)
return result
R, C = len(board), len(board[0])
begin = tuple(itertools.chain(*board))
end = tuple(range(1, R*C) + [0])
expected = {(C*i+j+1) % (R*C) : (i, j)
for i in xrange(R) for j in xrange(C)}
min_steps = heuristic_estimate(begin, R, C, expected)
closer, detour = [(begin.index(0), begin)], []
lookup = set()
while True:
if not closer:
if not detour:
return -1
min_steps += 2
closer, detour = detour, closer
zero, board = closer.pop()
if board == end:
return min_steps
if board not in lookup:
lookup.add(board)
r, c = divmod(zero, C)
for direction in ((-1, 0), (1, 0), (0, -1), (0, 1)):
i, j = r+direction[0], c+direction[1]
if 0 <= i < R and 0 <= j < C:
new_zero = i*C+j
tmp = list(board)
tmp[zero], tmp[new_zero] = tmp[new_zero], tmp[zero]
new_board = tuple(tmp)
r2, c2 = expected[board[new_zero]]
r1, c1 = divmod(zero, C)
r0, c0 = divmod(new_zero, C)
is_closer = dot((r1-r0, c1-c0), (r2-r0, c2-c0)) > 0
(closer if is_closer else detour).append((new_zero, new_board))
return min_steps
# Time: O((m * n) * (m * n)! * log((m * n)!))
# Space: O((m * n) * (m * n)!)
# A* Search Algorithm
class Solution2(object):
def slidingPuzzle(self, board):
"""
:type board: List[List[int]]
:rtype: int
"""
def heuristic_estimate(board, R, C, expected):
result = 0
for i in xrange(R):
for j in xrange(C):
val = board[C*i + j]
if val == 0: continue
r, c = expected[val]
result += abs(r-i) + abs(c-j)
return result
R, C = len(board), len(board[0])
begin = tuple(itertools.chain(*board))
end = tuple(range(1, R*C) + [0])
end_wrong = tuple(range(1, R*C-2) + [R*C-1, R*C-2, 0])
expected = {(C*i+j+1) % (R*C) : (i, j)
for i in xrange(R) for j in xrange(C)}
min_heap = [(0, 0, begin.index(0), begin)]
lookup = {begin: 0}
while min_heap:
f, g, zero, board = heapq.heappop(min_heap)
if board == end: return g
if board == end_wrong: return -1
if f > lookup[board]: continue
r, c = divmod(zero, C)
for direction in ((-1, 0), (1, 0), (0, -1), (0, 1)):
i, j = r+direction[0], c+direction[1]
if 0 <= i < R and 0 <= j < C:
new_zero = C*i+j
tmp = list(board)
tmp[zero], tmp[new_zero] = tmp[new_zero], tmp[zero]
new_board = tuple(tmp)
f = g+1+heuristic_estimate(new_board, R, C, expected)
if f < lookup.get(new_board, float("inf")):
lookup[new_board] = f
heapq.heappush(min_heap, (f, g+1, new_zero, new_board))
return -1
| # Time: O((m * n) * (m * n)! * log((m * n)!))
# Space: O((m * n) * (m * n)!)
# A* Search Algorithm
class Solution(object):
def slidingPuzzle(self, board):
"""
:type board: List[List[int]]
:rtype: int
"""
def heuristic_estimate(board, R, C, expected):
result = 0
for i in xrange(R):
for j in xrange(C):
val = board[C*i + j]
if val == 0: continue
r, c = expected[val]
result += abs(r-i) + abs(c-j)
return result
R, C = len(board), len(board[0])
begin = tuple(itertools.chain(*board))
end = tuple(range(1, R*C) + [0])
end_wrong = tuple(range(1, R*C-2) + [R*C-1, R*C-2, 0])
expected = {(C*i+j+1) % (R*C) : (i, j)
for i in xrange(R) for j in xrange(C)}
min_heap = [(0, 0, begin.index(0), begin)]
lookup = {begin: 0}
while min_heap:
f, g, zero, board = heapq.heappop(min_heap)
if board == end: return g
if board == end_wrong: return -1
if f > lookup[board]: continue
r, c = divmod(zero, C)
for direction in ((-1, 0), (1, 0), (0, -1), (0, 1)):
i, j = r+direction[0], c+direction[1]
if 0 <= i < R and 0 <= j < C:
new_zero = C*i+j
tmp = list(board)
tmp[zero], tmp[new_zero] = tmp[new_zero], tmp[zero]
new_board = tuple(tmp)
f = g+1+heuristic_estimate(new_board, R, C, expected)
if f < lookup.get(new_board, float("inf")):
lookup[new_board] = f
heapq.heappush(min_heap, (f, g+1, new_zero, new_board))
return -1
| Python | 0 |
10a510dc3234860c697945c8c37393a9b5790b6c | Update lims.py | access/lims.py | access/lims.py | #!/usr/bin/python
#Script that connects to the MySQL database and parses data from an html table
#Import the mysql.connector library/module
import sys
import time
import glob
import re
import os
import requests
from xml.etree import ElementTree
def readconfig():
configfile = os.getenv('HOME') + '/.scilifelabrc'
params = {}
with open(configfile, "r") as confs:
for line in confs:
if len(line) > 3 and not line[0] == "#":
pv = line.rstrip().split(" ")
arg = pv[0]
pv.pop(0)
params[arg] = ' '.join(pv)
return params
class limsconnect(object):
def __init__(self, User, Passwd, baseuri):
self.user = User
self.pwd = Passwd
self.uri = baseuri
self.entrypoints = { 'samples': 'limsid', 'artifacts': 'limsid' }
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type:
print '__exit__(%s, %s, %s)' % (exc_type, exc_val, exc_tb)
def getroot(self):
r = requests.get(self.uri, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def getentry(self, searchattribute, searchvalue):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def gettag(self, searchattribute, searchvalue, tag):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
if node.tag == tag:
hit = node.text
return hit
def getattribute(self, searchattribute, searchvalue, attribute):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
for key in node.attrib:
if (key == attribute)
hit = node.text
# hit = node.attrib[attribute]
return hit
# def getlist(self, term):
# r = requests.get(self.uri + , auth=(self.user, self.pwd))
# uri = node.attrib.get('uri')
| #!/usr/bin/python
#Script that connects to the MySQL database and parses data from an html table
#Import the mysql.connector library/module
import sys
import time
import glob
import re
import os
import requests
from xml.etree import ElementTree
def readconfig():
configfile = os.getenv('HOME') + '/.scilifelabrc'
params = {}
with open(configfile, "r") as confs:
for line in confs:
if len(line) > 3 and not line[0] == "#":
pv = line.rstrip().split(" ")
arg = pv[0]
pv.pop(0)
params[arg] = ' '.join(pv)
return params
class limsconnect(object):
def __init__(self, User, Passwd, baseuri):
self.user = User
self.pwd = Passwd
self.uri = baseuri
self.entrypoints = { 'samples': 'limsid', 'artifacts': 'limsid' }
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type:
print '__exit__(%s, %s, %s)' % (exc_type, exc_val, exc_tb)
def getroot(self):
r = requests.get(self.uri, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def getentry(self, searchattribute, searchvalue):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def gettag(self, searchattribute, searchvalue, tag):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
if node.tag == tag:
hit = node.text
return hit
# def getlist(self, term):
# r = requests.get(self.uri + , auth=(self.user, self.pwd))
# uri = node.attrib.get('uri')
| Python | 0 |
c2c21fabd144ec25fa46fefdfe7c460a39aa2454 | Update lims.py | access/lims.py | access/lims.py | #!/usr/bin/python
#Script that connects to the MySQL database and parses data from an html table
#Import the mysql.connector library/module
import sys
import time
import glob
import re
import os
import requests
from xml.etree import ElementTree
def readconfig():
configfile = os.getenv('HOME') + '/.scilifelabrc'
params = {}
with open(configfile, "r") as confs:
for line in confs:
if len(line) > 3 and not line[0] == "#":
pv = line.rstrip().split(" ")
arg = pv[0]
pv.pop(0)
params[arg] = ' '.join(pv)
return params
class limsconnect(object):
def __init__(self, User, Passwd, baseuri):
self.user = User
self.pwd = Passwd
self.uri = baseuri
self.entrypoints = { 'samples': 'limsid', 'artifacts': 'limsid' }
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type:
print '__exit__(%s, %s, %s)' % (exc_type, exc_val, exc_tb)
def getroot(self):
r = requests.get(self.uri, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def getentry(self, searchattribute, searchvalue):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def gettag(self, searchattribute, searchvalue, tag):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
if node.tag == tag:
hit = node.text
return hit
def getattribute(self, searchattribute, searchvalue, attribute):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
print node
for key in node.attrib:
print key
if (key == attribute):
hit = node.text
# hit = node.attrib[attribute]
return hit
# def getlist(self, term):
# r = requests.get(self.uri + , auth=(self.user, self.pwd))
# uri = node.attrib.get('uri')
| #!/usr/bin/python
#Script that connects to the MySQL database and parses data from an html table
#Import the mysql.connector library/module
import sys
import time
import glob
import re
import os
import requests
from xml.etree import ElementTree
def readconfig():
configfile = os.getenv('HOME') + '/.scilifelabrc'
params = {}
with open(configfile, "r") as confs:
for line in confs:
if len(line) > 3 and not line[0] == "#":
pv = line.rstrip().split(" ")
arg = pv[0]
pv.pop(0)
params[arg] = ' '.join(pv)
return params
class limsconnect(object):
def __init__(self, User, Passwd, baseuri):
self.user = User
self.pwd = Passwd
self.uri = baseuri
self.entrypoints = { 'samples': 'limsid', 'artifacts': 'limsid' }
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type:
print '__exit__(%s, %s, %s)' % (exc_type, exc_val, exc_tb)
def getroot(self):
r = requests.get(self.uri, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def getentry(self, searchattribute, searchvalue):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
return tree.iter()
def gettag(self, searchattribute, searchvalue, tag):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
if node.tag == tag:
hit = node.text
return hit
def getattribute(self, searchattribute, searchvalue, attribute):
r = requests.get(self.uri + searchattribute + '/' + searchvalue, auth=(self.user, self.pwd))
tree = ElementTree.fromstring(r.text)
hit = "No hit"
for node in tree:
for key in node.attrib:
if (key == attribute):
hit = node.text
# hit = node.attrib[attribute]
return hit
# def getlist(self, term):
# r = requests.get(self.uri + , auth=(self.user, self.pwd))
# uri = node.attrib.get('uri')
| Python | 0 |
17157a4eb9d4aa934da89892f4f42f851902b44c | fix missing return in celery SiteRouter :rage1: | frappe/celery_app.py | frappe/celery_app.py | # Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt
from __future__ import unicode_literals, absolute_import
from celery import Celery
# initiate logger
from celery.utils.log import get_task_logger
task_logger = get_task_logger(__name__)
from datetime import timedelta
import frappe
import json
import os
SITES_PATH = os.environ.get('SITES_PATH', '.')
# defaults
DEFAULT_CELERY_BROKER = "redis://localhost"
DEFAULT_CELERY_BACKEND = None
DEFAULT_SCHEDULER_INTERVAL = 300
LONGJOBS_PREFIX = "longjobs@"
_app = None
def get_celery():
global _app
if not _app:
conf = frappe.get_site_config(sites_path=SITES_PATH)
_app = Celery('frappe',
broker=conf.celery_broker or DEFAULT_CELERY_BROKER,
backend=conf.celery_result_backend or DEFAULT_CELERY_BACKEND)
setup_celery(_app, conf)
return _app
def setup_celery(app, conf):
app.autodiscover_tasks(frappe.get_all_apps(with_frappe=True, with_internal_apps=False,
sites_path=SITES_PATH))
app.conf.CELERY_TASK_SERIALIZER = 'json'
app.conf.CELERY_ACCEPT_CONTENT = ['json']
app.conf.CELERY_TIMEZONE = 'UTC'
if conf.celery_queue_per_site:
app.conf.CELERY_ROUTES = (SiteRouter(),)
app.conf.CELERYBEAT_SCHEDULE = get_beat_schedule(conf)
class SiteRouter(object):
def route_for_task(self, task, args=None, kwargs=None):
if hasattr(frappe.local, 'site'):
if kwargs and kwargs.get("event", "").endswith("_long"):
return get_queue(frappe.local.site, LONGJOBS_PREFIX)
else:
return get_queue(frappe.local.site)
return None
def get_queue(site, prefix=None):
return {'queue': "{}{}".format(prefix or "", site)}
def get_beat_schedule(conf):
schedule = {
'scheduler': {
'task': 'frappe.tasks.enqueue_scheduler_events',
'schedule': timedelta(seconds=conf.scheduler_interval or DEFAULT_SCHEDULER_INTERVAL)
},
}
if conf.celery_queue_per_site:
schedule['sync_queues'] = {
'task': 'frappe.tasks.sync_queues',
'schedule': timedelta(seconds=conf.scheduler_interval or DEFAULT_SCHEDULER_INTERVAL)
}
return schedule
def celery_task(*args, **kwargs):
return get_celery().task(*args, **kwargs)
if __name__ == '__main__':
get_celery().start()
| # Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt
from __future__ import unicode_literals, absolute_import
from celery import Celery
# initiate logger
from celery.utils.log import get_task_logger
task_logger = get_task_logger(__name__)
from datetime import timedelta
import frappe
import json
import os
SITES_PATH = os.environ.get('SITES_PATH', '.')
# defaults
DEFAULT_CELERY_BROKER = "redis://localhost"
DEFAULT_CELERY_BACKEND = None
DEFAULT_SCHEDULER_INTERVAL = 300
LONGJOBS_PREFIX = "longjobs@"
_app = None
def get_celery():
global _app
if not _app:
conf = frappe.get_site_config(sites_path=SITES_PATH)
_app = Celery('frappe',
broker=conf.celery_broker or DEFAULT_CELERY_BROKER,
backend=conf.celery_result_backend or DEFAULT_CELERY_BACKEND)
setup_celery(_app, conf)
return _app
def setup_celery(app, conf):
app.autodiscover_tasks(frappe.get_all_apps(with_frappe=True, with_internal_apps=False,
sites_path=SITES_PATH))
app.conf.CELERY_TASK_SERIALIZER = 'json'
app.conf.CELERY_ACCEPT_CONTENT = ['json']
app.conf.CELERY_TIMEZONE = 'UTC'
if conf.celery_queue_per_site:
app.conf.CELERY_ROUTES = (SiteRouter(),)
app.conf.CELERYBEAT_SCHEDULE = get_beat_schedule(conf)
class SiteRouter(object):
def route_for_task(self, task, args=None, kwargs=None):
if hasattr(frappe.local, 'site'):
if kwargs and kwargs.get("event", "").endswith("_long"):
get_queue(frappe.local.site, LONGJOBS_PREFIX)
else:
get_queue(frappe.local.site)
return None
def get_queue(site, prefix=None):
return {'queue': "{}{}".format(prefix or "", site)}
def get_beat_schedule(conf):
schedule = {
'scheduler': {
'task': 'frappe.tasks.enqueue_scheduler_events',
'schedule': timedelta(seconds=conf.scheduler_interval or DEFAULT_SCHEDULER_INTERVAL)
},
}
if conf.celery_queue_per_site:
schedule['sync_queues'] = {
'task': 'frappe.tasks.sync_queues',
'schedule': timedelta(seconds=conf.scheduler_interval or DEFAULT_SCHEDULER_INTERVAL)
}
return schedule
def celery_task(*args, **kwargs):
return get_celery().task(*args, **kwargs)
if __name__ == '__main__':
get_celery().start()
| Python | 0 |
619b51a579801b8ae211cb062b00149c19af11a7 | Make manage task more general | admin/tasks.py | admin/tasks.py | # -*- coding: utf-8 -*-
from __future__ import absolute_import
import os
from invoke import task, run
from tasks.utils import pip_install
from website import settings
HERE = os.path.dirname(os.path.abspath(__file__))
WHEELHOUSE_PATH = os.environ.get('WHEELHOUSE')
@task()
def manage(cmd_str):
"""Take command string and target (-t) for manage commands
:param args: ex. runserver, migrate
"""
manage_cmd = os.path.join(HERE, '..', 'manage.py')
env = 'DJANGO_SETTINGS_MODULE="admin.base.settings"'
cmd = '{} python {} {}'.format(env, manage_cmd, cmd_str)
run(cmd, echo=True, pty=True)
@task()
def assets(dev=False, watch=False):
"""Install and build static assets for admin."""
if os.getcwd() != HERE:
os.chdir(HERE)
npm = 'npm install'
if not dev:
npm += ' --production'
run(npm, echo=True)
bower_install()
# Always set clean=False to prevent possible mistakes
# on prod
webpack(clean=False, watch=watch, dev=dev)
@task(aliases=['pack'])
def webpack(clean=False, watch=False, dev=False):
"""Build static assets with webpack."""
if clean:
clean_assets()
if os.getcwd() != HERE:
os.chdir(HERE)
webpack_bin = os.path.join(HERE, 'node_modules', 'webpack', 'bin',
'webpack.js')
args = [webpack_bin]
if settings.DEBUG_MODE and dev:
args += ['--colors']
else:
args += ['--progress']
if watch:
args += ['--watch']
config_file = 'webpack.admin.config.js' if dev else 'webpack.prod.config.js'
args += ['--config {0}'.format(config_file)]
command = ' '.join(args)
run(command, echo=True)
@task
def clean_assets():
"""Remove built JS files."""
public_path = os.path.join(HERE, 'static', 'public')
js_path = os.path.join(public_path, 'js')
run('rm -rf {0}'.format(js_path), echo=True)
@task(aliases=['bower'])
def bower_install():
if os.getcwd() != HERE:
os.chdir(HERE)
bower_bin = os.path.join(HERE, 'node_modules', 'bower', 'bin', 'bower')
run('{} prune'.format(bower_bin), echo=True)
run('{} install'.format(bower_bin), echo=True)
@task(aliases=['req'])
def requirements():
req_file = os.path.join(HERE, '..', 'requirements', 'admin.txt')
run(pip_install(req_file), echo=True)
| # -*- coding: utf-8 -*-
from __future__ import absolute_import
import os
from invoke import task, run
from tasks.utils import pip_install
from website import settings
HERE = os.path.dirname(os.path.abspath(__file__))
WHEELHOUSE_PATH = os.environ.get('WHEELHOUSE')
@task()
def manage(cmd_str, target=''):
"""Take command string and target (-t) for manage commands
:param args: ex. runserver, migrate
"""
manage_cmd = os.path.join(HERE, '..', 'manage.py')
env = 'DJANGO_SETTINGS_MODULE="admin.base.settings"'
cmd = '{} python {} {} {}'.format(env, manage_cmd, cmd_str, target)
run(cmd, echo=True, pty=True)
@task()
def assets(dev=False, watch=False):
"""Install and build static assets for admin."""
if os.getcwd() != HERE:
os.chdir(HERE)
npm = 'npm install'
if not dev:
npm += ' --production'
run(npm, echo=True)
bower_install()
# Always set clean=False to prevent possible mistakes
# on prod
webpack(clean=False, watch=watch, dev=dev)
@task(aliases=['pack'])
def webpack(clean=False, watch=False, dev=False):
"""Build static assets with webpack."""
if clean:
clean_assets()
if os.getcwd() != HERE:
os.chdir(HERE)
webpack_bin = os.path.join(HERE, 'node_modules', 'webpack', 'bin',
'webpack.js')
args = [webpack_bin]
if settings.DEBUG_MODE and dev:
args += ['--colors']
else:
args += ['--progress']
if watch:
args += ['--watch']
config_file = 'webpack.admin.config.js' if dev else 'webpack.prod.config.js'
args += ['--config {0}'.format(config_file)]
command = ' '.join(args)
run(command, echo=True)
@task
def clean_assets():
"""Remove built JS files."""
public_path = os.path.join(HERE, 'static', 'public')
js_path = os.path.join(public_path, 'js')
run('rm -rf {0}'.format(js_path), echo=True)
@task(aliases=['bower'])
def bower_install():
if os.getcwd() != HERE:
os.chdir(HERE)
bower_bin = os.path.join(HERE, 'node_modules', 'bower', 'bin', 'bower')
run('{} prune'.format(bower_bin), echo=True)
run('{} install'.format(bower_bin), echo=True)
@task(aliases=['req'])
def requirements():
req_file = os.path.join(HERE, '..', 'requirements', 'admin.txt')
run(pip_install(req_file), echo=True)
| Python | 0.000954 |
50a2ac8e5aeee2c4435707a72c22092e28ecf5ba | Update zeromq_server.py | examples/zeromq_server.py | examples/zeromq_server.py | from jsonrpcserver import Success, method, dispatch
import zmq
socket = zmq.Context().socket(zmq.REP)
@method
def ping():
return Success("pong")
if __name__ == "__main__":
socket.bind("tcp://*:5000")
while True:
request = socket.recv().decode()
socket.send_string(dispatch(request))
| import zmq
from jsonrpcserver import Success, method, dispatch
socket = zmq.Context().socket(zmq.REP)
@method
def ping():
return Success("pong")
if __name__ == "__main__":
socket.bind("tcp://*:5000")
while True:
request = socket.recv().decode()
socket.send_string(dispatch(request))
| Python | 0.000001 |
80a5609b35baecfe8d208b9abec36b25c10bb609 | Revert "minor date fix" | generic/reporting/reports.py | generic/reporting/reports.py | import datetime, time
from generic.reporting.forms import DateRangeForm
class Column(object):
report = None
order = 0
title = None
chart_title = None
chart_subtitle = None
chart_yaxis = None
def get_title(self):
return self.title
def set_report(self, report):
self.report = report
def add_to_report(self, report, key, dictionary):
pass
def get_chart(self):
return None
def get_redirect(self):
None
def get_view_function(self):
return None
def get_order(self):
return self.order
def __init__(self, order=0, title=None, chart_title=None, chart_subtitle=None, chart_yaxis=None):
self.order = order
self.title = title
self.chart_title = chart_title
self.chart_subtitle = chart_subtitle
self.chart_yaxis = chart_yaxis
class BasicDateGetter(object):
def get_dates(self, request):
to_ret = {}
if self.request.POST:
form = DateRangeForm(self.request.POST)
if form.is_valid():
to_ret['start'] = form.cleaned_data['start']
to_ret['end'] = form.cleaned_data['end']
return to_ret
def set_default_dates(self, request, context):
dates = self.get_dates(request)
max_date = dates.setdefault('max', datetime.datetime.now())
min_date = dates.setdefault('min', max_date - datetime.timedelta(days=365))
min_date = datetime.datetime(min_date.year, min_date.month, 1)
max_date = datetime.datetime(max_date.year, max_date.month + 1, 1) - datetime.timedelta(days=1)
start_date = dates.setdefault('start', min_date)
start_date = datetime.datetime(start_date.year, start_date.month, start_date.day)
end_date = dates.setdefault('end', max_date)
end_date = datetime.datetime(end_date.year, end_date.month, end_date.day)
max_ts = time.mktime(max_date.timetuple())
min_ts = time.mktime(min_date.timetuple())
start_ts = time.mktime(start_date.timetuple())
end_ts = time.mktime(end_date.timetuple())
context.update({
'max_ts':max_ts, \
'min_ts':min_ts, \
'selected_ts':[(start_ts, 'start',), (end_ts, 'end',)],
'start_ts':start_ts,
'end_ts':end_ts,
'start_date':start_date,
'end_date':end_date,
'ts_range':range(long(min_ts), long(max_ts) + 1, 86400), \
})
def add_dates_to_context(self, request, context):
self.set_default_dates(request, context)
| import datetime, time
from generic.reporting.forms import DateRangeForm
class Column(object):
report = None
order = 0
title = None
chart_title = None
chart_subtitle = None
chart_yaxis = None
def get_title(self):
return self.title
def set_report(self, report):
self.report = report
def add_to_report(self, report, key, dictionary):
pass
def get_chart(self):
return None
def get_redirect(self):
None
def get_view_function(self):
return None
def get_order(self):
return self.order
def __init__(self, order=0, title=None, chart_title=None, chart_subtitle=None, chart_yaxis=None):
self.order = order
self.title = title
self.chart_title = chart_title
self.chart_subtitle = chart_subtitle
self.chart_yaxis = chart_yaxis
class BasicDateGetter(object):
def get_dates(self, request):
to_ret = {}
if self.request.POST:
form = DateRangeForm(self.request.POST)
if form.is_valid():
to_ret['start'] = form.cleaned_data['start']
to_ret['end'] = form.cleaned_data['end']
return to_ret
def set_default_dates(self, request, context):
dates = self.get_dates(request)
max_date = dates.setdefault('max', datetime.datetime.now())
min_date = dates.setdefault('min', max_date - datetime.timedelta(days=365))
min_date = datetime.datetime(min_date.year, min_date.month, 1)
max_date = datetime.datetime(max_date.year, max_date.month, 1) + datetime.timedelta(days=30)
start_date = dates.setdefault('start', min_date)
start_date = datetime.datetime(start_date.year, start_date.month, start_date.day)
end_date = dates.setdefault('end', max_date)
end_date = datetime.datetime(end_date.year, end_date.month, end_date.day)
max_ts = time.mktime(max_date.timetuple())
min_ts = time.mktime(min_date.timetuple())
start_ts = time.mktime(start_date.timetuple())
end_ts = time.mktime(end_date.timetuple())
context.update({
'max_ts':max_ts, \
'min_ts':min_ts, \
'selected_ts':[(start_ts, 'start',), (end_ts, 'end',)],
'start_ts':start_ts,
'end_ts':end_ts,
'start_date':start_date,
'end_date':end_date,
'ts_range':range(long(min_ts), long(max_ts) + 1, 86400), \
})
def add_dates_to_context(self, request, context):
self.set_default_dates(request, context)
| Python | 0 |
709e9dddf94e8afa43d908e92f7c7d6bc0817e46 | remove commented line | humid_temp.py | humid_temp.py | import weather_utils
import Adafruit_DHT
def get_data():
humidity, temp_c = Adafruit_DHT.read_retry(Adafruit_DHT.AM2302, 4)
temp_f = weather_utils.c_to_f(temp_c)
return { 'temp_f': temp_f,
'temp_c': temp_c,
'humidity': humidity,
'dewptf': weather_utils.dewpoint_f(temp_f, humidity) }
| # import Adafruit_Python_DHT
import weather_utils
import Adafruit_DHT
def get_data():
humidity, temp_c = Adafruit_DHT.read_retry(Adafruit_DHT.AM2302, 4)
temp_f = weather_utils.c_to_f(temp_c)
return { 'temp_f': temp_f,
'temp_c': temp_c,
'humidity': humidity,
'dewptf': weather_utils.dewpoint_f(temp_f, humidity) }
| Python | 0 |
b359d2418210499573705015f057a79d71899da7 | Fix for empty raw-data option (#109) | alertaclient/commands/cmd_send.py | alertaclient/commands/cmd_send.py |
import sys
import click
@click.command('send', short_help='Send an alert')
@click.option('--resource', '-r', metavar='RESOURCE', required=True, help='Resource under alarm')
@click.option('--event', '-e', metavar='EVENT', required=True, help='Event name')
@click.option('--environment', '-E', metavar='ENVIRONMENT', help='Environment eg. Production, Development')
@click.option('--severity', '-s', metavar='SEVERITY', help='Severity eg. critical, major, minor, warning')
@click.option('--correlate', '-C', metavar='EVENT', multiple=True, help='List of related events eg. node_up, node_down')
@click.option('--service', '-S', metavar='SERVICE', multiple=True, help='List of affected services eg. app name, Web, Network, Storage, Database, Security')
@click.option('--group', '-g', metavar='GROUP', help='Group event by type eg. OS, Performance')
@click.option('--value', '-v', metavar='VALUE', help='Event value')
@click.option('--text', '-t', metavar='DESCRIPTION', help='Description of alert')
@click.option('--tag', '-T', 'tags', multiple=True, metavar='TAG', help='List of tags eg. London, os:linux, AWS/EC2')
@click.option('--attributes', '-A', multiple=True, metavar='KEY=VALUE', help='List of attributes eg. priority=high')
@click.option('--origin', '-O', metavar='ORIGIN', help='Origin of alert in form app/host')
@click.option('--type', metavar='EVENT_TYPE', help='Event type eg. exceptionAlert, performanceAlert, nagiosAlert')
@click.option('--timeout', metavar='EXPIRES', type=int, help='Seconds before an open alert will be expired')
@click.option('--raw-data', metavar='STRING', help='Raw data of orignal alert eg. SNMP trap PDU. \'@\' to read from file, \'-\' to read from stdin')
@click.option('--customer', metavar='STRING', help='Customer (Admin only)')
@click.pass_obj
def cli(obj, resource, event, environment, severity, correlate, service, group, value, text, tags, attributes, origin, type, timeout, raw_data, customer):
"""Send an alert."""
client = obj['client']
# read raw data from file or stdin
if raw_data and raw_data.startswith('@'):
raw_data_file = raw_data.lstrip('@')
with open(raw_data_file, 'r') as f:
raw_data = f.read()
elif raw_data == '-':
raw_data = sys.stdin.read()
try:
id, alert, message = client.send_alert(
resource=resource,
event=event,
environment=environment,
severity=severity,
correlate=correlate,
service=service,
group=group,
value=value,
text=text,
tags=tags,
attributes=dict(a.split('=') for a in attributes),
origin=origin,
type=type,
timeout=timeout,
raw_data=raw_data,
customer=customer
)
except Exception as e:
click.echo('ERROR: {}'.format(e))
sys.exit(1)
if alert:
if alert.repeat:
message = '{} duplicates'.format(alert.duplicate_count)
else:
message = '{} -> {}'.format(alert.previous_severity, alert.severity)
click.echo('{} ({})'.format(id, message))
|
import sys
import click
@click.command('send', short_help='Send an alert')
@click.option('--resource', '-r', metavar='RESOURCE', required=True, help='Resource under alarm')
@click.option('--event', '-e', metavar='EVENT', required=True, help='Event name')
@click.option('--environment', '-E', metavar='ENVIRONMENT', help='Environment eg. Production, Development')
@click.option('--severity', '-s', metavar='SEVERITY', help='Severity eg. critical, major, minor, warning')
@click.option('--correlate', '-C', metavar='EVENT', multiple=True, help='List of related events eg. node_up, node_down')
@click.option('--service', '-S', metavar='SERVICE', multiple=True, help='List of affected services eg. app name, Web, Network, Storage, Database, Security')
@click.option('--group', '-g', metavar='GROUP', help='Group event by type eg. OS, Performance')
@click.option('--value', '-v', metavar='VALUE', help='Event value')
@click.option('--text', '-t', metavar='DESCRIPTION', help='Description of alert')
@click.option('--tag', '-T', 'tags', multiple=True, metavar='TAG', help='List of tags eg. London, os:linux, AWS/EC2')
@click.option('--attributes', '-A', multiple=True, metavar='KEY=VALUE', help='List of attributes eg. priority=high')
@click.option('--origin', '-O', metavar='ORIGIN', help='Origin of alert in form app/host')
@click.option('--type', metavar='EVENT_TYPE', help='Event type eg. exceptionAlert, performanceAlert, nagiosAlert')
@click.option('--timeout', metavar='EXPIRES', type=int, help='Seconds before an open alert will be expired')
@click.option('--raw-data', metavar='STRING', help='Raw data of orignal alert eg. SNMP trap PDU. \'@\' to read from file, \'-\' to read from stdin')
@click.option('--customer', metavar='STRING', help='Customer (Admin only)')
@click.pass_obj
def cli(obj, resource, event, environment, severity, correlate, service, group, value, text, tags, attributes, origin, type, timeout, raw_data, customer):
"""Send an alert."""
client = obj['client']
# read raw data from file or stdin
if raw_data.startswith('@'):
raw_data_file = raw_data.lstrip('@')
with open(raw_data_file, 'r') as f:
raw_data = f.read()
elif raw_data == '-':
raw_data = sys.stdin.read()
try:
id, alert, message = client.send_alert(
resource=resource,
event=event,
environment=environment,
severity=severity,
correlate=correlate,
service=service,
group=group,
value=value,
text=text,
tags=tags,
attributes=dict(a.split('=') for a in attributes),
origin=origin,
type=type,
timeout=timeout,
raw_data=raw_data,
customer=customer
)
except Exception as e:
click.echo('ERROR: {}'.format(e))
sys.exit(1)
if alert:
if alert.repeat:
message = '{} duplicates'.format(alert.duplicate_count)
else:
message = '{} -> {}'.format(alert.previous_severity, alert.severity)
click.echo('{} ({})'.format(id, message))
| Python | 0.000001 |
c06e904588503768331a580d8766bf4a47f83574 | add option "-k" to limit tests in test-install command (#2635) | allennlp/commands/test_install.py | allennlp/commands/test_install.py | """
The ``test-install`` subcommand verifies
an installation by running the unit tests.
.. code-block:: bash
$ allennlp test-install --help
usage: allennlp test-install [-h] [--run-all]
[--include-package INCLUDE_PACKAGE]
Test that installation works by running the unit tests.
optional arguments:
-h, --help show this help message and exit
--run-all By default, we skip tests that are slow or download
large files. This flag will run all tests.
--include-package INCLUDE_PACKAGE
additional packages to include
"""
import argparse
import logging
import os
import pathlib
import pytest
import allennlp
from allennlp.commands.subcommand import Subcommand
logger = logging.getLogger(__name__) # pylint: disable=invalid-name
class TestInstall(Subcommand):
def add_subparser(self, name: str, parser: argparse._SubParsersAction) -> argparse.ArgumentParser:
# pylint: disable=protected-access
description = '''Test that installation works by running the unit tests.'''
subparser = parser.add_parser(
name, description=description, help='Run the unit tests.')
subparser.add_argument('--run-all', action="store_true",
help="By default, we skip tests that are slow "
"or download large files. This flag will run all tests.")
subparser.add_argument('-k', type=str, default=None,
help="Limit tests by setting pytest -k argument")
subparser.set_defaults(func=_run_test)
return subparser
def _get_module_root():
return pathlib.Path(allennlp.__file__).parent
def _run_test(args: argparse.Namespace):
initial_working_dir = os.getcwd()
module_parent = _get_module_root().parent
logger.info("Changing directory to %s", module_parent)
os.chdir(module_parent)
test_dir = os.path.join(module_parent, "allennlp")
logger.info("Running tests at %s", test_dir)
if args.k:
pytest_k = ['-k', args.k]
pytest_m = ['-m', 'not java']
if args.run_all:
logger.warning("the argument '-k' overwrites '--run-all'.")
elif args.run_all:
pytest_k = []
pytest_m = []
else:
pytest_k = ['-k', 'not sniff_test']
pytest_m = ['-m', 'not java']
exit_code = pytest.main([test_dir, '--color=no'] + pytest_k + pytest_m)
# Change back to original working directory after running tests
os.chdir(initial_working_dir)
exit(exit_code)
| """
The ``test-install`` subcommand verifies
an installation by running the unit tests.
.. code-block:: bash
$ allennlp test-install --help
usage: allennlp test-install [-h] [--run-all]
[--include-package INCLUDE_PACKAGE]
Test that installation works by running the unit tests.
optional arguments:
-h, --help show this help message and exit
--run-all By default, we skip tests that are slow or download
large files. This flag will run all tests.
--include-package INCLUDE_PACKAGE
additional packages to include
"""
import argparse
import logging
import os
import pathlib
import pytest
import allennlp
from allennlp.commands.subcommand import Subcommand
logger = logging.getLogger(__name__) # pylint: disable=invalid-name
class TestInstall(Subcommand):
def add_subparser(self, name: str, parser: argparse._SubParsersAction) -> argparse.ArgumentParser:
# pylint: disable=protected-access
description = '''Test that installation works by running the unit tests.'''
subparser = parser.add_parser(
name, description=description, help='Run the unit tests.')
subparser.add_argument('--run-all', action="store_true",
help="By default, we skip tests that are slow "
"or download large files. This flag will run all tests.")
subparser.set_defaults(func=_run_test)
return subparser
def _get_module_root():
return pathlib.Path(allennlp.__file__).parent
def _run_test(args: argparse.Namespace):
initial_working_dir = os.getcwd()
module_parent = _get_module_root().parent
logger.info("Changing directory to %s", module_parent)
os.chdir(module_parent)
test_dir = os.path.join(module_parent, "allennlp")
logger.info("Running tests at %s", test_dir)
if args.run_all:
# TODO(nfliu): remove this when notebooks have been rewritten as markdown.
exit_code = pytest.main([test_dir, '--color=no', '-k', 'not notebooks_test'])
else:
exit_code = pytest.main([test_dir, '--color=no', '-k', 'not sniff_test and not notebooks_test',
'-m', 'not java'])
# Change back to original working directory after running tests
os.chdir(initial_working_dir)
exit(exit_code)
| Python | 0 |
c7c39f9c32ca6f52ba60335ebbaa2b960e74fa8f | handle conversion better | twtoolbox/streaming.py | twtoolbox/streaming.py | # Twitter Toolbox for Python
# Copyright 2016 Hugo Hromic
#
# 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.
"""Twitter Public Streaming API module."""
import logging
import json
from tweepy import StreamListener, Stream
from .helpers import init_logger, read_config, get_oauth_api
from .helpers import ensure_at_least_one
# module logging
LOGGER = logging.getLogger(__name__)
init_logger(LOGGER)
class PassThroughStreamListener(StreamListener):
"""Stream Listener that passes incoming messages directly to a writer."""
def __init__(self, writer, limit=0, **kwargs):
super(self.__class__, self).__init__(**kwargs)
self.writer = writer
self.limit = limit
self.num_written = 0
def on_status(self, status):
"""Write an incoming Tweet to the writer."""
self.writer.write("%s\n" % json.dumps(status._json, separators=(",", ":"))) # pylint: disable=protected-access
self.num_written += 1
if self.num_written == self.limit:
return False
return True
def on_error(self, status_code):
"""Handle stream errors."""
if status_code == 420:
LOGGER.error("too many connection attempts, stopping stream")
return False
def _get_stream(writer, config, limit=0):
api = get_oauth_api(config)
listener = PassThroughStreamListener(writer, limit=limit)
return Stream(auth=api.auth, listener=listener)
def get_sample(writer):
"""Get hydrated Tweet-objects from the sample Streaming API endpoint."""
LOGGER.info("get_sample() starting")
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("sample", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.sample()
# finished
LOGGER.info("get_sample() finished")
def get_filter(writer, follow=None, track=None, locations=None):
"""Get hydrated Tweet-objects from the filter Streaming API endpoint."""
LOGGER.info("get_filter() starting")
ensure_at_least_one(follow=follow, track=track, locations=locations)
follow = [str(f) for f in follow] if follow else None
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("filter", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.filter(follow=follow, track=track, locations=locations)
# finished
LOGGER.info("get_filter() finished")
def get_firehose(writer):
"""Get hydrated Tweet-objects from the firehose Streaming API endpoint."""
LOGGER.info("get_firehose() starting")
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("firehose", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.firehose()
# finished
LOGGER.info("get_firehose() finished")
| # Twitter Toolbox for Python
# Copyright 2016 Hugo Hromic
#
# 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.
"""Twitter Public Streaming API module."""
import logging
import json
from tweepy import StreamListener, Stream
from .helpers import init_logger, read_config, get_oauth_api
from .helpers import ensure_at_least_one
# module logging
LOGGER = logging.getLogger(__name__)
init_logger(LOGGER)
class PassThroughStreamListener(StreamListener):
"""Stream Listener that passes incoming messages directly to a writer."""
def __init__(self, writer, limit=0, **kwargs):
super(self.__class__, self).__init__(**kwargs)
self.writer = writer
self.limit = limit
self.num_written = 0
def on_status(self, status):
"""Write an incoming Tweet to the writer."""
self.writer.write("%s\n" % json.dumps(status._json, separators=(",", ":"))) # pylint: disable=protected-access
self.num_written += 1
if self.num_written == self.limit:
return False
return True
def on_error(self, status_code):
"""Handle stream errors."""
if status_code == 420:
LOGGER.error("too many connection attempts, stopping stream")
return False
def _get_stream(writer, config, limit=0):
api = get_oauth_api(config)
listener = PassThroughStreamListener(writer, limit=limit)
return Stream(auth=api.auth, listener=listener)
def get_sample(writer):
"""Get hydrated Tweet-objects from the sample Streaming API endpoint."""
LOGGER.info("get_sample() starting")
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("sample", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.sample()
# finished
LOGGER.info("get_sample() finished")
def get_filter(writer, follow=None, track=None, locations=None):
"""Get hydrated Tweet-objects from the filter Streaming API endpoint."""
LOGGER.info("get_filter() starting")
ensure_at_least_one(follow=follow, track=track, locations=locations)
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("filter", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.filter(follow=[str(f) for f in follow], track=track, locations=locations)
# finished
LOGGER.info("get_filter() finished")
def get_firehose(writer):
"""Get hydrated Tweet-objects from the firehose Streaming API endpoint."""
LOGGER.info("get_firehose() starting")
# initialize a Streaming API object and run the endpoint
config = read_config()
limit = config.getint("firehose", "limit")
stream = _get_stream(writer, config, limit=limit)
stream.firehose()
# finished
LOGGER.info("get_firehose() finished")
| Python | 0 |
411b95793ff5e73e14949aabc3466a9f39336267 | Figure out what's in that resp | micro.py | micro.py | #!/usr/bin/env python
from __future__ import division
from flask import Flask, render_template, url_for, session, request, g, \
redirect, flash
from flaskext.oauth import OAuth
import os
#setup code
app = Flask(__name__)
app.secret_key = 'pagerduty'
oauth = OAuth()
facebook = oauth.remote_app('facebook',
base_url='https://graph.facebook.com/',
request_token_url=None,
access_token_url='/oauth/access_token',
authorize_url='https://www.facebook.com/dialog/oauth',
consumer_key='187344811378870',
consumer_secret='7f75c822a976c064f479e4fe93c68d9d',
request_token_params={'scope': 'read_stream'}
)
#Ok, let's see... We need to integrate some Graph API in here. I may
#not get around to Twitter by Tuesday. I need to look into a pythonic
#replacement for PHP's strtotime(), then use that to request the
#correct wall posts/news feed for the date entered.
##Conventions I will be using:
#g.user is the oauth access token
#access_token is the key (for dicts) that I will be using to store the
#access token under.
####Load from cookie
@app.before_request
def before_request():
g.user = None
if 'access_token' in session:
g.user = session['access_token']
####Views
@app.route('/')
def index():
name = None
if g.user is not None:
resp = facebook.get('/me')
if resp.status == 200:
name = resp.data['name']
else:
flash('Unable to get news feed data.')
return render_template('index.html', name=name)
@app.route('/login')
def login():
if g.user is None:
return facebook.authorize(callback=url_for('authorized',
next=request.args.get('next') or request.referrer or None,
_external=True))
else:
return redirect(url_for('index'))
@app.route('/logout')
def logout():
session.pop('access_token', None)
g.user = None
return redirect(url_for('index'))
@app.route('/authorized')
@facebook.authorized_handler
def authorized(resp):
next_url = request.args.get('next') or url_for('index')
#Figure out what resp is (i.e. print str(resp))
print str(resp)
if resp is None:
flash('You need to allow us to pull your data!')
return redirect(next_url)
g.user = resp['access_token']
session['access_token'] = g.user
return redirect(next_url)
@app.route('/<int:month>/<int:day>/<int:year>')
def display(month, day, year):
return "Stella is estudpido!"
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
####Non-view handlers
@facebook.tokengetter
def get_fb_token():
return g.user, ''
if __name__=='__main__':
#Set up for Heroku
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port, debug=True)
| #!/usr/bin/env python
from __future__ import division
from flask import Flask, render_template, url_for, session, request, g, \
redirect, flash
from flaskext.oauth import OAuth
import os
#setup code
app = Flask(__name__)
app.secret_key = 'pagerduty'
oauth = OAuth()
facebook = oauth.remote_app('facebook',
base_url='https://graph.facebook.com/',
request_token_url=None,
access_token_url='/oauth/access_token',
authorize_url='https://www.facebook.com/dialog/oauth',
consumer_key='187344811378870',
consumer_secret='7f75c822a976c064f479e4fe93c68d9d',
request_token_params={'scope': 'read_stream'}
)
#Ok, let's see... We need to integrate some Graph API in here. I may
#not get around to Twitter by Tuesday. I need to look into a pythonic
#replacement for PHP's strtotime(), then use that to request the
#correct wall posts/news feed for the date entered.
##Conventions I will be using:
#g.user is the oauth access token
#access_token is the key (for dicts) that I will be using to store the
#access token under.
####Load from cookie
@app.before_request
def before_request():
g.user = None
if 'access_token' in session:
g.user = session['access_token']
####Views
@app.route('/')
def index():
name = None
if g.user is not None:
resp = facebook.get('/me')
if resp.status == 200:
name = resp.data['name']
else:
flash('Unable to get news feed data.')
return render_template('index.html', name=name)
@app.route('/login')
def login():
if g.user is None:
return facebook.authorize(callback=url_for('authorized',
next=request.args.get('next') or request.referrer or None,
_external=True))
else:
return redirect(url_for('index'))
@app.route('/logout')
def logout():
session.pop('access_token', None)
g.user = None
return redirect(url_for('index'))
@app.route('/authorized')
@facebook.authorized_handler
def authorized(resp):
next_url = request.args.get('next') or url_for('index')
if resp is None:
flash('You need to allow us to pull your data!')
return redirect(next_url)
g.user = resp['access_token']
session['access_token'] = g.user
return redirect(next_url)
@app.route('/<int:month>/<int:day>/<int:year>')
def display(month, day, year):
return "Stella is estudpido!"
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
####Non-view handlers
@facebook.tokengetter
def get_fb_token():
return g.user, ''
if __name__=='__main__':
#Set up for Heroku
port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port, debug=True)
| Python | 0.99993 |
5a0c6904c23a84d1ee931e3ef82f297197141222 | add twitter and flags | light.py | light.py | #!/usr/bin/python
"""
light.py
Read analog values from the photoresistor
=======
run with:
sudo ./light.py
Copyright 2014 David P. Bradway (dpb6@duke.edu)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
__author__ = "David Bradway"
__email__ = "dpb6@duke.edu"
__license__ = "Apache v2.0"
def main():
import Adafruit_BBIO.ADC as ADC
import time
import datetime
import numpy as np
import matplotlib.pyplot as plt
import collections
import twitter
# Set Flags
plotit = 0
debug = 0
printit = 1
tweetit = 1
# Set ADC
sensor_pin = 'P9_40'
ADC.setup()
# Set data collection buffer
buflength = 15
circbuf=collections.deque(maxlen=buflength)
# Plot the raw data
if plotit:
#plt.axis([0, 1000, -.1, 1.7])
plt.ion()
plt.show()
# Print table of data
if debug:
print('Time\tVolts\t\tMedian\t\tVariance\t\tStable\t\t\tnewstateflag')
if tweetit:
api = twitter.Api(consumer_key='',
consumer_secret='',
access_token_key='',
access_token_secret='')
if debug:
print api.VerifyCredentials()
i = 0
med = 0
stable = 0
variance = 0
newstateflag = False
while True:
now = datetime.datetime.now()
reading = ADC.read(sensor_pin)
volts = reading * 1.800
circbuf.append(volts)
med = np.median(circbuf)
variance = np.var(circbuf)
if variance < 0.001:
stable = med
newstateflag = False
if variance > 0.01 and newstateflag == False:
if med > stable:
update = 'Lights on %s' % (str(now))
if printit:
print(update)
if tweetit:
status = api.PostUpdate(update)
newstateflag = True
elif med < stable:
update = 'Lights off %s' % (str(now))
if printit:
print(update)
if tweetit:
status = api.PostUpdate(update)
newstateflag = True
if debug:
print('%s\t%f\t%f\t%f\t%f\t%f' % (now.second, volts, med, variance, stable, newstateflag))
if plotit:
plt.scatter(i, med)
plt.draw()
time.sleep(.25)
i=i+1
if __name__ == "__main__":
main()
| #!/usr/bin/python
"""
light.py
Read analog values from the photoresistor
=======
run with:
sudo ./light.py
Copyright 2014 David P. Bradway (dpb6@duke.edu)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
__author__ = "David Bradway"
__email__ = "dpb6@duke.edu"
__license__ = "Apache v2.0"
def main():
import Adafruit_BBIO.ADC as ADC
import time
import datetime
import numpy as np
import matplotlib.pyplot as plt
sensor_pin = 'P9_40'
ADC.setup()
#plt.axis([0, 1000, 0, 1])
plt.ion()
plt.show()
print('Time\tReading\t\tVolts')
i=0
while True:
now = datetime.datetime.now()
reading = ADC.read(sensor_pin)
volts = reading * 1.800
print('%s\t%f\t%f' % (now.second, reading, volts))
plt.scatter(i, volts)
plt.draw()
time.sleep(0.1)
i=i+1
if __name__ == "__main__":
main()
| Python | 0 |
e6b3a02376f832ee1bf79905ececfc76933197fc | Fix client | client/client.py | client/client.py | import socket
import os
import json
import time
class Client():
def __init__(self):
abs_prefix = os.path.join(os.path.dirname(__file__), "../client")
with open(abs_prefix + '/config.json','r') as f:
conf = json.load(f)
self.port = conf["port"]
self.host = conf["host"]
print (self.host,self.port)
self.password = conf["password"]
self.sock = socket.socket()
self.sock.connect((self.host, self.port))
self.sock.send(self.password)
assert self.sock.recv(1024) == "welcome"
def Send(self, msg):
self.sock.send(msg)
if msg == "quit":
self.Close()
return False
data = self.sock.recv(1024)
print data
return True
def Prompt(self):
return self.Send(raw_input("boom> "))
def Close(self):
self.sock.close()
if __name__ == "__main__":
c = Client()
print "You are now connected to a TiaraBoom server."
print "This server enforces NO RATE LIMITS!!!"
print "Please respect that Tiara does not wish to respond to more than a few requests per hour!"
print "If you receive an error other than a syntax error, or the server does not respond, please DO NOT TRY AGAIN"
print "Instead, contact support at 513-284-5321"
print "Enter a command, or try \"help\""
print "to exit, type quit"
while True:
if not c.Prompt():
break
print "good bye"
| import socket
import os
import json
import time
class Client():
def __init__(self):
abs_prefix = os.path.join(os.path.dirname(__file__), "../data")
with open(abs_prefix + '/config.json','r') as f:
conf = json.load(f)
self.port = conf["port"]
self.host = conf["host"]
self.password = conf["password"]
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock = socket.socket()
self.sock.connect((self.host, self.port))
self.sock.send(self.password)
assert self.sock.recv(1024) == "welcome"
def Send(self, msg):
self.sock.send(msg)
if msg == "quit":
self.sock.Close()
return False
data = self.sock.recv(1024)
print data
return True
def Prompt(self):
return self.Send(raw_input("boom> "))
def Close(self):
self.sock.close()
if __name__ == "__main__":
c = Client()
print "You are now connected to a TiaraBoom server."
print "This server enforces NO RATE LIMITS!!!"
print "Please respect that Tiara does not wish to respond to more than a few requests per hour!"
print "If you receive an error other than a syntax error, or the server does not respond, please DO NOT TRY AGAIN"
print "Instead, contact support at 513-284-5321"
print "Enter a command, or try \"help\""
print "to exit, type quit"
while True:
if not c.Prompt():
break
print "good bye"
| Python | 0.000001 |
d4d4a065323d61073eb80a4f7f04d2902a33e4fe | fix ntb publish service get_filename for events | server/ntb/publish/ntb_publish_service.py | server/ntb/publish/ntb_publish_service.py | # -*- coding: utf-8; -*-
#
# This file is part of Superdesk.
#
# Copyright 2013, 2016 Sourcefabric z.u. and contributors.
#
# For the full copyright and license information, please see the
# AUTHORS and LICENSE files distributed with this source code, or
# at https://www.sourcefabric.org/superdesk/license
from superdesk.publish.publish_service import PublishService, set_publish_service
from xml.etree import ElementTree as ET
import logging
logger = logging.getLogger(__name__)
class NTBPublishService(PublishService):
DEFAULT_EXT = "xml"
@classmethod
def get_filename(cls, item):
# we reparse formatted item to get filename from <meta name="filename"> element
# this way we are sure that we have the exact same filename
try:
xml = ET.fromstring(item['formatted_item'])
except (KeyError, ET.ParseError) as e:
filename = None
logger.error("Error on parsing, can't get filename: {}".format(e))
else:
try:
filename = xml.find('head/meta[@name="filename"]').attrib['content']
except AttributeError:
filename = None
if not filename:
return super(NTBPublishService, cls).get_filename(item)
return filename
set_publish_service(NTBPublishService)
| # -*- coding: utf-8; -*-
#
# This file is part of Superdesk.
#
# Copyright 2013, 2016 Sourcefabric z.u. and contributors.
#
# For the full copyright and license information, please see the
# AUTHORS and LICENSE files distributed with this source code, or
# at https://www.sourcefabric.org/superdesk/license
from superdesk.publish.publish_service import PublishService, set_publish_service
from xml.etree import ElementTree as ET
import logging
logger = logging.getLogger(__name__)
class NTBPublishService(PublishService):
DEFAULT_EXT = "xml"
@classmethod
def get_filename(cls, item):
# we reparse formatted item to get filename from <meta name="filename"> element
# this way we are sure that we have the exact same filename
try:
xml = ET.fromstring(item['formatted_item'])
except (KeyError, ET.ParseError) as e:
filename = None
logger.error("Error on parsing, can't get filename: {}".format(e))
else:
filename = xml.find('head/meta[@name="filename"]').attrib['content']
if not filename:
return super(NTBPublishService, cls).get_filename(item)
return filename
set_publish_service(NTBPublishService)
| Python | 0 |
936e6427c48ebbf16a12fb3afa0f48ad6c397046 | fix feature input to hb-view | Lib/diffenator/utils.py | Lib/diffenator/utils.py | import subprocess
from PIL import Image
from fontTools.varLib.mutator import instantiateVariableFont
try:
from StringIO import StringIO
except ImportError: # py3 workaround
from io import BytesIO as StringIO
def render_string(font, string, features=None, pt_size=128):
"""Use Harfbuzz to render a string"""
cmd = ['hb-view', '--font-size=%d' % pt_size]
if font.instance_coordinates:
location = ''
for axis, val in font.instance_coordinates.items():
location += '{}={}, '.format(axis, val)
cmd += ['--variations=%s' % location]
if features:
# ignore aalt tag. This feat is used so users can access glyphs
# via a glyph pallette.
# https://typedrawers.com/discussion/1319/opentype-aalt-feature
# glyphsapp will autogen this feature
cmd += ['--features=%s' % ','.join(features).replace("aalt,", "")]
cmd += [font.path, u'{}'.format(string)]
try:
img = StringIO(subprocess.check_output(cmd))
return Image.open(img)
except FileNotFoundError:
raise OSError(
"hb-view was not found. Check if Harbuzz is installed."
)
| import subprocess
from PIL import Image
from fontTools.varLib.mutator import instantiateVariableFont
try:
from StringIO import StringIO
except ImportError: # py3 workaround
from io import BytesIO as StringIO
def render_string(font, string, features=None, pt_size=128):
"""Use Harfbuzz to render a string"""
cmd = ['hb-view', '--font-size=%d' % pt_size]
if font.instance_coordinates:
location = ''
for axis, val in font.instance_coordinates.items():
location += '{}={}, '.format(axis, val)
cmd += ['--variations=%s' % location]
if features:
cmd += ['--features=%s' % features]
cmd += [font.path, u'{}'.format(string)]
try:
img = StringIO(subprocess.check_output(cmd))
return Image.open(img)
except FileNotFoundError:
raise OSError(
"hb-view was not found. Check if Harbuzz is installed."
)
| Python | 0 |
1d51a59a6e1406852a081585e252afab892e9756 | Handle cases where the states don't exist when getting dialogue config's states | go/apps/dialogue/vumi_app.py | go/apps/dialogue/vumi_app.py | # -*- test-case-name: go.apps.dialogue.tests.test_vumi_app -*-
import pkg_resources
import json
from vumi.application.sandbox import SandboxResource
from go.apps.jsbox.vumi_app import JsBoxConfig, JsBoxApplication
def determine_endpoints(poll):
names = set(
s['channel_type']
for s in poll.get('states', []) if s['type'] == 'send')
types = poll.get('channel_types', [])
return [t['label'] for t in types if t['name'] in names]
def dialogue_js_config(conv):
poll = conv.config.get("poll", {})
config = {
"name": "poll-%s" % conv.key,
"endpoints": determine_endpoints(poll)
}
poll_metadata = poll.get('poll_metadata', {})
delivery_class = poll_metadata.get('delivery_class')
if delivery_class is not None:
config['delivery_class'] = delivery_class
return config
class PollConfigResource(SandboxResource):
"""Resource that provides access to dialogue conversation config."""
def _get_config(self, conversation):
"""Returns a virtual sandbox config for the given dialogue.
:returns:
JSON string containg the configuration dictionary.
"""
return json.dumps(dialogue_js_config(conversation))
def _get_poll(self, conversation):
"""Returns the poll definition from the given dialogue.
:returns:
JSON string containing the poll definition.
"""
poll = conversation.config.get("poll")
return poll
def handle_get(self, api, command):
key = command.get("key")
if key is None:
return self.reply(command, success=False)
conversation = self.app_worker.conversation_for_api(api)
if key == "config":
value = self._get_config(conversation)
elif key == "poll":
value = self._get_poll(conversation)
else:
# matches what is returned for unknown keys by
# go.apps.jsbox.vumi_app.ConversationConfigResource
value = {}
return self.reply(command, value=value, success=True)
class DialogueConfig(JsBoxConfig):
_cached_javascript = None
@property
def javascript(self):
if self._cached_javascript is None:
self._cached_javascript = pkg_resources.resource_string(
"go.apps.dialogue", "vumi_app.js")
return self._cached_javascript
class DialogueApplication(JsBoxApplication):
CONFIG_CLASS = DialogueConfig
worker_name = 'dialogue_application'
def get_jsbox_js_config(self, conv):
return dialogue_js_config(conv)
| # -*- test-case-name: go.apps.dialogue.tests.test_vumi_app -*-
import pkg_resources
import json
from vumi.application.sandbox import SandboxResource
from go.apps.jsbox.vumi_app import JsBoxConfig, JsBoxApplication
def determine_endpoints(poll):
names = set(
s['channel_type']
for s in poll['states'] if s['type'] == 'send')
types = poll.get('channel_types', [])
return [t['label'] for t in types if t['name'] in names]
def dialogue_js_config(conv):
poll = conv.config.get("poll", {})
config = {
"name": "poll-%s" % conv.key,
"endpoints": determine_endpoints(poll)
}
poll_metadata = poll.get('poll_metadata', {})
delivery_class = poll_metadata.get('delivery_class')
if delivery_class is not None:
config['delivery_class'] = delivery_class
return config
class PollConfigResource(SandboxResource):
"""Resource that provides access to dialogue conversation config."""
def _get_config(self, conversation):
"""Returns a virtual sandbox config for the given dialogue.
:returns:
JSON string containg the configuration dictionary.
"""
return json.dumps(dialogue_js_config(conversation))
def _get_poll(self, conversation):
"""Returns the poll definition from the given dialogue.
:returns:
JSON string containing the poll definition.
"""
poll = conversation.config.get("poll")
return poll
def handle_get(self, api, command):
key = command.get("key")
if key is None:
return self.reply(command, success=False)
conversation = self.app_worker.conversation_for_api(api)
if key == "config":
value = self._get_config(conversation)
elif key == "poll":
value = self._get_poll(conversation)
else:
# matches what is returned for unknown keys by
# go.apps.jsbox.vumi_app.ConversationConfigResource
value = {}
return self.reply(command, value=value, success=True)
class DialogueConfig(JsBoxConfig):
_cached_javascript = None
@property
def javascript(self):
if self._cached_javascript is None:
self._cached_javascript = pkg_resources.resource_string(
"go.apps.dialogue", "vumi_app.js")
return self._cached_javascript
class DialogueApplication(JsBoxApplication):
CONFIG_CLASS = DialogueConfig
worker_name = 'dialogue_application'
def get_jsbox_js_config(self, conv):
return dialogue_js_config(conv)
| Python | 0.000002 |
7bce0c3e1c2cc0ca8f37916ad88abd0f91ba2c38 | Update Keras.py | tanh/Keras.py | tanh/Keras.py | from keras.datasets import mnist
from keras.initializers import RandomUniform
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
batch_size = 128
epochs = 30
learning_rate = 0.5
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape([x_train.shape[0], -1]).astype('float32') / 255
y_train = to_categorical(y_train, num_classes=10)
x_test = x_test.reshape([x_test.shape[0], -1]).astype('float32') / 255
y_test = to_categorical(y_test, num_classes=10)
model = Sequential()
model.add(Dense(512,
activation='tanh',
input_shape=(784,),
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.add(Dense(512,
activation='tanh',
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.add(Dense(10,
activation='softmax',
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=learning_rate),
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
| from keras.datasets import mnist
from keras.initializers import RandomUniform
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
batch_size = 128
epochs = 30
learning_rate = 0.5
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape([x_train.shape[0], -1]).astype('float32') / 255
y_train = to_categorical(y_train, num_classes=10)
x_test = x_test.reshape([x_test.shape[0], -1]).astype('float32') / 255
y_test = to_categorical(y_test, num_classes=10)
model = Sequential()
model.add(Dense(512,
activation='tanh',
input_shape=(784,),
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.add(Dense(512,
activation='tanh',
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.add(Dense(10,
activation='softmax',
kernel_initializer=RandomUniform(minval=-0.01, maxval=0.01)))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=learning_rate),
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
| Python | 0 |
ac545eb8b21ed1bfadc5649fc84e58da10a35846 | Change `compose` to return a string instead of a generator | tinysrt.py | tinysrt.py | #!/usr/bin/env python
'''A tiny library for parsing, modifying, and composing SRT files.'''
import functools
import re
from datetime import timedelta
from itertools import groupby
SUBTITLE_PATTERN = r'(\d+)\n(\d+:\d+:\d+,\d+) --> (\d+:\d+:\d+,\d+)\n(.+?)\n\n'
SUBTITLE_REGEX = re.compile(SUBTITLE_PATTERN, re.MULTILINE | re.DOTALL)
@functools.total_ordering
class Subtitle(object):
def __init__(self, index, start, end, content):
self.index = index
self.start = start
self.end = end
self.content = content
def __eq__(self, other):
return self.__dict__ == other.__dict__
def __lt__(self, other):
return self.start < other.start
def to_srt(self):
return '%d\n%s --> %s\n%s\n\n' % (
self.index, timedelta_to_srt_timestamp(self.start),
timedelta_to_srt_timestamp(self.end), self.content,
)
def timedelta_to_srt_timestamp(timedelta_timestamp):
'''Convert a timedelta to an SRT timestamp.'''
hrs, remainder = divmod(timedelta_timestamp.seconds, 3600)
mins, secs = divmod(remainder, 60)
msecs = timedelta_timestamp.microseconds // 1000
return '%02d:%02d:%02d,%03d' % (hrs, mins, secs, msecs)
def srt_timestamp_to_timedelta(srt_timestamp):
'''Convert an SRT timestamp to a timedelta.'''
hrs, mins, secs, msecs = map(int, re.split('[,:]', srt_timestamp))
return timedelta(hours=hrs, minutes=mins, seconds=secs, milliseconds=msecs)
def parse(srt):
'''Convert an SRT formatted string to a generator of Subtitle objects.'''
for match in SUBTITLE_REGEX.finditer(srt):
raw_index, raw_start, raw_end, content = match.groups()
yield Subtitle(
index=int(raw_index), start=srt_timestamp_to_timedelta(raw_start),
end=srt_timestamp_to_timedelta(raw_end), content=content,
)
def parse_file(srt_stream):
'''Parse an SRT formatted stream into Subtitle objects.'''
for is_sep, lines in groupby(srt_stream, lambda line: line != '\n'):
if is_sep:
srt_block = ''.join(lines) + '\n'
subtitle, = parse(srt_block)
yield subtitle
def compose(subtitles):
'''Convert an iterator of Subtitle objects to SRT formatted strings.'''
return ''.join(subtitle.to_srt() for subtitle in subtitles)
def compose_file(subtitles, srt_stream):
for subtitle in subtitles:
srt_stream.write(subtitle.to_srt())
| #!/usr/bin/env python
'''A tiny library for parsing, modifying, and composing SRT files.'''
import functools
import re
from datetime import timedelta
from itertools import groupby
SUBTITLE_PATTERN = r'(\d+)\n(\d+:\d+:\d+,\d+) --> (\d+:\d+:\d+,\d+)\n(.+?)\n\n'
SUBTITLE_REGEX = re.compile(SUBTITLE_PATTERN, re.MULTILINE | re.DOTALL)
@functools.total_ordering
class Subtitle(object):
def __init__(self, index, start, end, content):
self.index = index
self.start = start
self.end = end
self.content = content
def __eq__(self, other):
return self.__dict__ == other.__dict__
def __lt__(self, other):
return self.start < other.start
def to_srt(self):
return '%d\n%s --> %s\n%s\n\n' % (
self.index, timedelta_to_srt_timestamp(self.start),
timedelta_to_srt_timestamp(self.end), self.content,
)
def timedelta_to_srt_timestamp(timedelta_timestamp):
'''Convert a timedelta to an SRT timestamp.'''
hrs, remainder = divmod(timedelta_timestamp.seconds, 3600)
mins, secs = divmod(remainder, 60)
msecs = timedelta_timestamp.microseconds // 1000
return '%02d:%02d:%02d,%03d' % (hrs, mins, secs, msecs)
def srt_timestamp_to_timedelta(srt_timestamp):
'''Convert an SRT timestamp to a timedelta.'''
hrs, mins, secs, msecs = map(int, re.split('[,:]', srt_timestamp))
return timedelta(hours=hrs, minutes=mins, seconds=secs, milliseconds=msecs)
def parse(srt):
'''Convert an SRT formatted string to a generator of Subtitle objects.'''
for match in SUBTITLE_REGEX.finditer(srt):
raw_index, raw_start, raw_end, content = match.groups()
yield Subtitle(
index=int(raw_index), start=srt_timestamp_to_timedelta(raw_start),
end=srt_timestamp_to_timedelta(raw_end), content=content,
)
def parse_file(srt_stream):
'''Parse an SRT formatted stream into Subtitle objects.'''
for is_sep, lines in groupby(srt_stream, lambda line: line != '\n'):
if is_sep:
srt_block = ''.join(lines) + '\n'
subtitle, = parse(srt_block)
yield subtitle
def compose(subtitles):
'''Convert an iterator of Subtitle objects to SRT formatted strings.'''
return (subtitle.to_srt() for subtitle in subtitles)
def compose_file(subtitles, srt_stream):
for srt_block in compose(subtitles):
srt_stream.write(srt_block)
| Python | 0 |
7977939caa8b521bd99112a3d368e343db3169cd | Fix a bug about losing the owner of a password when doing a modification on the password | yithlibraryserver/views.py | yithlibraryserver/views.py | import json
import bson
from pyramid.httpexceptions import HTTPBadRequest
from pyramid.view import view_config, view_defaults
from yithlibraryserver.errors import password_not_found, invalid_password_id
from yithlibraryserver.utils import jsonable
from yithlibraryserver.validation import validate_password
@view_defaults(route_name='password_collection_view', renderer='json')
class PasswordCollectionRESTView(object):
def __init__(self, request):
self.request = request
self.user = self.request.matchdict['user']
@view_config(request_method='OPTIONS', renderer='string')
def options(self):
headers = self.request.response.headers
headers['Access-Control-Allow-Methods'] = 'GET, POST'
headers['Access-Control-Allow-Headers'] = 'Origin, Content-Type, Accept'
return ''
@view_config(request_method='GET')
def get(self):
return [jsonable(p)
for p in self.request.db.passwords.find({'owner': self.user})]
@view_config(request_method='POST')
def post(self):
password, errors = validate_password(self.request.body,
self.request.charset)
if errors:
result = {'message': ','.join(errors)}
return HTTPBadRequest(body=json.dumps(result),
content_type='application/json')
# add the password to the database
password['owner'] = self.user
_id = self.request.db.passwords.insert(password, safe=True)
password['_id'] = str(_id)
return password
@view_defaults(route_name='password_view', renderer='json')
class PasswordRESTView(object):
def __init__(self, request):
self.request = request
self.user = self.request.matchdict['user']
self.password_id = self.request.matchdict['password']
@view_config(request_method='OPTIONS', renderer='string')
def options(self):
headers = self.request.response.headers
headers['Access-Control-Allow-Methods'] = 'GET, PUT, DELETE'
headers['Access-Control-Allow-Headers'] = 'Origin, Content-Type, Accept'
return ''
@view_config(request_method='GET')
def get(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
password = self.request.db.passwords.find_one(_id)
if password is None:
return password_not_found()
else:
return jsonable(password)
@view_config(request_method='PUT')
def put(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
password, errors = validate_password(self.request.body,
self.request.charset,
_id)
if errors:
result = {'message': ','.join(errors)}
return HTTPBadRequest(body=json.dumps(result),
content_type='application/json')
# update the password in the database
password['owner'] = self.user
result = self.request.db.passwords.update({'_id': _id},
password,
safe=True)
# result['n'] is the number of documents updated
# See http://www.mongodb.org/display/DOCS/getLastError+Command#getLastErrorCommand-ReturnValue
if result['n'] == 1:
return jsonable(password)
else:
return password_not_found()
@view_config(request_method='DELETE')
def delete(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
result = self.request.db.passwords.remove(_id, safe=True)
if result['n'] == 1:
return ''
else:
return password_not_found()
| import json
import bson
from pyramid.httpexceptions import HTTPBadRequest
from pyramid.view import view_config, view_defaults
from yithlibraryserver.errors import password_not_found, invalid_password_id
from yithlibraryserver.utils import jsonable
from yithlibraryserver.validation import validate_password
@view_defaults(route_name='password_collection_view', renderer='json')
class PasswordCollectionRESTView(object):
def __init__(self, request):
self.request = request
self.user = self.request.matchdict['user']
@view_config(request_method='OPTIONS', renderer='string')
def options(self):
headers = self.request.response.headers
headers['Access-Control-Allow-Methods'] = 'GET, POST'
headers['Access-Control-Allow-Headers'] = 'Origin, Content-Type, Accept'
return ''
@view_config(request_method='GET')
def get(self):
return [jsonable(p)
for p in self.request.db.passwords.find({'owner': self.user})]
@view_config(request_method='POST')
def post(self):
password, errors = validate_password(self.request.body,
self.request.charset)
if errors:
result = {'message': ','.join(errors)}
return HTTPBadRequest(body=json.dumps(result),
content_type='application/json')
# add the password to the database
password['owner'] = self.user
_id = self.request.db.passwords.insert(password, safe=True)
password['_id'] = str(_id)
return password
@view_defaults(route_name='password_view', renderer='json')
class PasswordRESTView(object):
def __init__(self, request):
self.request = request
# the user is actually not used in this view since
# the passwords ids are globally unique
self.user = self.request.matchdict['user']
self.password_id = self.request.matchdict['password']
@view_config(request_method='OPTIONS', renderer='string')
def options(self):
headers = self.request.response.headers
headers['Access-Control-Allow-Methods'] = 'GET, PUT, DELETE'
headers['Access-Control-Allow-Headers'] = 'Origin, Content-Type, Accept'
return ''
@view_config(request_method='GET')
def get(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
password = self.request.db.passwords.find_one(_id)
if password is None:
return password_not_found()
else:
return jsonable(password)
@view_config(request_method='PUT')
def put(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
password, errors = validate_password(self.request.body,
self.request.charset,
_id)
if errors:
result = {'message': ','.join(errors)}
return HTTPBadRequest(body=json.dumps(result),
content_type='application/json')
# update the password in the database
result = self.request.db.passwords.update({'_id': _id},
password,
safe=True)
# result['n'] is the number of documents updated
# See http://www.mongodb.org/display/DOCS/getLastError+Command#getLastErrorCommand-ReturnValue
if result['n'] == 1:
return jsonable(password)
else:
return password_not_found()
@view_config(request_method='DELETE')
def delete(self):
try:
_id = bson.ObjectId(self.password_id)
except bson.errors.InvalidId:
return invalid_password_id()
result = self.request.db.passwords.remove(_id, safe=True)
if result['n'] == 1:
return ''
else:
return password_not_found()
| Python | 0.000006 |
fa99e3eb8504016fee706347fe162c2692b74c70 | Support concurrent loops. | gearman/client.py | gearman/client.py | """
Gearman client implementation.
"""
import sys
import struct
from collections import deque
from twisted.internet import defer
from twisted.protocols import stateful
from twisted.python import log
from constants import *
__all__ = ['GearmanProtocol', 'GearmanWorker']
class GearmanProtocol(stateful.StatefulProtocol):
"""Base protocol for handling gearman connections."""
def makeConnection(self, transport):
stateful.StatefulProtocol.makeConnection(self, transport)
self.receivingCommand = 0
self.deferreds = deque()
def send_raw(self, cmd, data=''):
"""Send a command with the given data with no response."""
self.transport.write(REQ_MAGIC)
self.transport.write(struct.pack(">II", cmd, len(data)))
self.transport.write(data)
def send(self, cmd, data=''):
"""Send a command and get a deferred waiting for the response."""
self.send_raw(cmd, data)
d = defer.Deferred()
self.deferreds.append(d)
return d
def getInitialState(self):
return self._headerReceived, HEADER_LEN
def connectionLost(self, reason):
try:
for d in list(self.deferreds):
d.errback(reason)
except:
log.err()
self.deferreds.clear()
def _headerReceived(self, header):
if header[:4] != RES_MAGIC:
log.msg("Invalid header magic returned, failing.")
self.transport.loseConnection()
return
cmd, size = struct.unpack(">II", header[4:])
self.receivingCommand = cmd
return self._completed, size
def _completed(self, data):
d = self.deferreds.popleft()
d.callback((self.receivingCommand, data))
self.receivingCommand = 0
return self._headerReceived, HEADER_LEN
def pre_sleep(self):
"""Enter a sleep state."""
return self.send(PRE_SLEEP)
def echo(self, data="hello"):
"""Send an echo request."""
return self.send(ECHO_REQ, data)
class GearmanJob(object):
"""A gearman job."""
def __init__(self, raw_data):
self.handle, self.function, self.data = raw_data.split("\0", 2)
def __repr__(self):
return "<GearmanJob %s func=%s with %d bytes of data>" % (self.handle,
self.function,
len(self.data))
class GearmanWorker(object):
"""A gearman worker."""
def __init__(self, protocol):
self.protocol = protocol
self.functions = {}
self.sleeping = None
def registerFunction(self, name, func):
"""Register the ability to perform a function."""
self.functions[name] = func
self.protocol.send_raw(CAN_DO, name)
def _send_job_res(self, cmd, job, data=''):
self.protocol.send_raw(cmd, job.handle + "\0" + data)
def _sleep(self):
if not self.sleeping:
self.sleeping = self.protocol.pre_sleep()
def _clear(x):
self.sleeping = None
self.sleeping.addBoth(_clear)
return self.sleeping
@defer.inlineCallbacks
def getJob(self):
"""Get the next job."""
# If we're currently sleeping, attach to the existing sleep.
if self.sleeping:
yield self._sleep()
stuff = yield self.protocol.send(GRAB_JOB)
while stuff[0] == NO_JOB:
yield self._sleep()
stuff = yield self.protocol.send(GRAB_JOB)
defer.returnValue(GearmanJob(stuff[1]))
@defer.inlineCallbacks
def _finishJob(self, job):
assert job
f = self.functions[job.function]
assert f
try:
rv = yield f(job.data)
if rv is None:
rv = ""
self._send_job_res(WORK_COMPLETE, job, rv)
except:
x = sys.exc_info()
self._send_job_res(WORK_EXCEPTION, job, str(x))
self._send_job_res(WORK_FAIL, job)
def __iter__(self):
while True:
yield self.getJob().addCallback(self._finishJob)
| """
Gearman client implementation.
"""
import sys
import struct
from collections import deque
from twisted.internet import defer
from twisted.protocols import stateful
from twisted.python import log
from constants import *
__all__ = ['GearmanProtocol', 'GearmanWorker']
class GearmanProtocol(stateful.StatefulProtocol):
"""Base protocol for handling gearman connections."""
def makeConnection(self, transport):
stateful.StatefulProtocol.makeConnection(self, transport)
self.receivingCommand = 0
self.deferreds = deque()
def send_raw(self, cmd, data=''):
"""Send a command with the given data with no response."""
self.transport.write(REQ_MAGIC)
self.transport.write(struct.pack(">II", cmd, len(data)))
self.transport.write(data)
def send(self, cmd, data=''):
"""Send a command and get a deferred waiting for the response."""
self.send_raw(cmd, data)
d = defer.Deferred()
self.deferreds.append(d)
return d
def getInitialState(self):
return self._headerReceived, HEADER_LEN
def connectionLost(self, reason):
try:
for d in list(self.deferreds):
d.errback(reason)
except:
log.err()
self.deferreds.clear()
def _headerReceived(self, header):
if header[:4] != RES_MAGIC:
log.msg("Invalid header magic returned, failing.")
self.transport.loseConnection()
return
cmd, size = struct.unpack(">II", header[4:])
self.receivingCommand = cmd
return self._completed, size
def _completed(self, data):
d = self.deferreds.popleft()
d.callback((self.receivingCommand, data))
self.receivingCommand = 0
return self._headerReceived, HEADER_LEN
def pre_sleep(self):
"""Enter a sleep state."""
return self.send(PRE_SLEEP)
def echo(self, data="hello"):
"""Send an echo request."""
return self.send(ECHO_REQ, data)
class GearmanJob(object):
"""A gearman job."""
def __init__(self, raw_data):
self.handle, self.function, self.data = raw_data.split("\0", 2)
def __repr__(self):
return "<GearmanJob %s func=%s with %d bytes of data>" % (self.handle,
self.function,
len(self.data))
class GearmanWorker(object):
"""A gearman worker."""
def __init__(self, protocol):
self.protocol = protocol
self.functions = {}
def registerFunction(self, name, func):
"""Register the ability to perform a function."""
self.functions[name] = func
self.protocol.send_raw(CAN_DO, name)
def _send_job_res(self, cmd, job, data=''):
self.protocol.send_raw(cmd, job.handle + "\0" + data)
@defer.inlineCallbacks
def getJob(self):
"""Get the next job."""
stuff = yield self.protocol.send(GRAB_JOB)
while stuff[0] == NO_JOB:
yield self.protocol.pre_sleep()
stuff = yield self.protocol.send(GRAB_JOB)
defer.returnValue(GearmanJob(stuff[1]))
@defer.inlineCallbacks
def _finishJob(self, job):
assert job
f = self.functions[job.function]
assert f
try:
rv = yield f(job.data)
if rv is None:
rv = ""
self._send_job_res(WORK_COMPLETE, job, rv)
except:
x = sys.exc_info()
self._send_job_res(WORK_EXCEPTION, job, str(x))
self._send_job_res(WORK_FAIL, job)
def __iter__(self):
while True:
yield self.getJob().addCallback(self._finishJob)
| Python | 0 |
4063d94b405a41ead8d5c3df5a1d27dd1dba140f | remove config for warmup | gae/tap/warmup.py | gae/tap/warmup.py | # -*- coding: utf-8 -*-
from functools import wraps
import os
import sys
import webapp2
# Search Path
def execute_once(func):
@wraps(func)
def inner(_result=[None], *argv, **kwargv):
if _result[0] is None:
_result[0] = func(*argv, **kwargv)
if _result[0] is None:
raise ValueError("The return value must be not `None`.")
return _result[0]
return inner
@execute_once
def sys_path_append():
try:
import __main__ as main
except ImportError:
is_shell = False
else:
is_shell = not hasattr(main, "__file__")
base_path = os.environ.get("SITE_PACKAGES", "site-packages")
path = base_path
if path not in sys.path and os.path.exists(path):
sys.path.append(path)
if os.path.exists(base_path):
path = os.path.join(base_path, "packages")
if path not in sys.path:
sys.path.append(path)
if os.path.exists(path):
for zipfile in os.listdir(path):
if zipfile.endswith(".zip"):
zipfile_path = os.path.join(path, zipfile)
if zipfile_path not in sys.path:
sys.path.append(zipfile_path)
if is_shell or sys.argv[0].endswith("/sphinx-build"):
import google
base = os.path.join(os.path.dirname(google.__file__), "../lib/")
for webapp2 in ["webapp2-2.5.2", "webapp2"]:
path = os.path.join(base, webapp2)
if os.path.exists(path):
sys.path.append(path)
break
for path in ["endpoints-1.0", "protorpc-1.0", "jinja2"]:
sys.path.append(os.path.join(base, path))
return True
sys_path_append()
from js.angular import angular_cookies, angular_resource
from js.bootstrap import bootstrap
import tap
class WarmUp(tap.RequestHandler):
@tap.head(angular_cookies, angular_resource, bootstrap)
def get(self):
pass
app = webapp2.WSGIApplication([
("/_ah/warmup", WarmUp),
])
| # -*- coding: utf-8 -*-
from functools import wraps
import os
import sys
from google.appengine.api import lib_config
import webapp2
# Config
class ConfigDefaults(object):
IS_TEST = "unittest" in sys.modules.keys()
SITE_PACKAGES = "site-packages"
config = lib_config.register("warmup", ConfigDefaults.__dict__)
# Search Path
def execute_once(func):
@wraps(func)
def inner(_result=[None], *argv, **kwargv):
if _result[0] is None:
_result[0] = func(*argv, **kwargv)
if _result[0] is None:
raise ValueError("The return value must be not `None`.")
return _result[0]
return inner
@execute_once
def sys_path_append():
try:
import __main__ as main
except ImportError:
is_shell = False
else:
is_shell = not hasattr(main, "__file__")
base_path = config.SITE_PACKAGES
if config.IS_TEST or is_shell:
base_path = os.path.abspath(base_path)
path = base_path
if path not in sys.path and os.path.exists(path):
sys.path.append(path)
if os.path.exists(base_path):
path = os.path.join(base_path, "packages")
if path not in sys.path:
sys.path.append(path)
if os.path.exists(path):
for zipfile in os.listdir(path):
if zipfile.endswith(".zip"):
zipfile_path = os.path.join(path, zipfile)
if zipfile_path not in sys.path:
sys.path.append(zipfile_path)
if is_shell or sys.argv[0].endswith("/sphinx-build"):
import google
base = os.path.join(os.path.dirname(google.__file__), "../lib/")
for webapp2 in ["webapp2-2.5.2", "webapp2"]:
path = os.path.join(base, webapp2)
if os.path.exists(path):
sys.path.append(path)
break
for path in ["endpoints-1.0", "protorpc-1.0", "jinja2"]:
sys.path.append(os.path.join(base, path))
elif config.IS_TEST:
import google
base = os.path.join(os.path.dirname(google.__file__), "../lib/")
for path in ["endpoints-1.0"]:
sys.path.append(os.path.join(base, path))
return True
sys_path_append()
from js.angular import angular_cookies, angular_resource
from js.bootstrap import bootstrap
import tap
class WarmUp(tap.RequestHandler):
@tap.head(angular_cookies, angular_resource, bootstrap)
def get(self):
pass
app = webapp2.WSGIApplication([
("/_ah/warmup", WarmUp),
])
| Python | 0.000001 |
3dfac1e6ef418e180d4967aba921ff527ff31e6b | Update ittr_multiplayer.py | nose_ittr/ittr_multiplayer.py | nose_ittr/ittr_multiplayer.py | __author__ = 'Sergey Ragatsky'
__version__ = '0.0.2'
import re
import logging
from types import FunctionType
from itertools import product
logger = logging.getLogger(__name__)
def ittr(*args, **kwargs):
"""
Decorator that adds iteration attributes to test method
"""
def update_attr(func):
# combining kwargs and args dict with ittr dict
ittrs = {str(item): item for item in args or []}
ittr_dict = getattr(func, 'ittr', dict())
ittr_dict.update(ittrs)
ittr_dict.update(kwargs)
setattr(func, 'ittr', ittr_dict)
return func
return update_attr
class IttrMultiplayer(type):
"""
Multiples the tests in a given test class by
the parameters given in ittr decorator.
"""
def __new__(mcs, name, bases, dct):
# check if the class been multiplied by IttrMultiplier
if dct.get('is_multiplied'):
return type.__new__(mcs, name, bases, dct)
for attribute_name, attribute in dct.items():
# if not a method continue
if not type(attribute) == FunctionType:
logging.debug('attribute {0} is not a method'.format(attribute_name))
continue
# is method decorated with platform attr
if not hasattr(attribute, 'ittr') or not attribute.ittr:
logging.debug('method {0} has not attr decorator'.format(attribute_name))
continue
# create product of all the iterators
b = [map(lambda value: (key, value), values)
for key, values in attribute.ittr.iteritems() if values]
products = map(dict, product(*b))
for prod in products:
logging.debug('method product: {0}'.format(prod))
suffix = re.sub(r'\W+', '',
str(prod.values())
.translate(None, "[]'")
.replace(',', '_'))
logging.debug('method suffix: {0}'.format(suffix))
# in case itts passed are empty
if not suffix:
logging.debug('Empty suffix, product: {0}'.format(prod))
continue
new_func_name = attribute_name + '_' + suffix
# combine both product and ittr dict to be added to new method
func_params = dict(attribute.func_dict, **prod)
mirror_func = mcs._attribute_injector(attribute, **func_params)
setattr(mirror_func, 'ittr', prod)
# assign new name and docstring and save back at our class
mirror_func.func_name = new_func_name
mirror_func.func_doc = attribute.func_doc
dct[new_func_name] = mirror_func
# set no test flag to original test method
attribute.__test__ = False
# mark has been multiplied
dct['is_multiplied'] = True
return type.__new__(mcs, name, bases, dct)
@classmethod
def _attribute_injector(cls, func, **keywords):
def injector(*fargs, **fkeywords):
# transfer ittr and attr to self when called
self = fargs[0]
for name, value in keywords.iteritems():
setattr(self, name, value)
return func(*fargs, **fkeywords)
# transfers all attr and ittr to newfunc
for name, value in keywords.iteritems():
setattr(injector, name, value)
setattr(injector, 'keywords', keywords)
return injector
| __author__ = 'Sergey Ragatsky'
__version__ = '0.0.2'
import re
import logging
from types import FunctionType
from itertools import product
logger = logging.getLogger(__name__)
def ittr(*args, **kwargs):
"""
Decorator that adds iteration attributes to test method
"""
def update_attr(func):
# combining kwargs and args dict with ittr dict
ittrs = {str(item): item for item in args or []}
ittr_dict = getattr(func, 'ittr', dict())
ittr_dict.update(ittrs)
ittr_dict.update(kwargs)
setattr(func, 'ittr', ittr_dict)
return func
return update_attr
class IttrMultiplayer(type):
"""
Multiples the tests in a given test class by
the parameters given in ittr decorator.
"""
def __new__(mcs, name, bases, dct):
# check if the class been multiplied by IttrMultiplayer
if dct.get('is_multiplied'):
return type.__new__(mcs, name, bases, dct)
for attribute_name, attribute in dct.items():
# if not a method continue
if not type(attribute) == FunctionType:
logging.debug('attribute {0} is not a method'.format(attribute_name))
continue
# is method decorated with platform attr
if not hasattr(attribute, 'ittr') or not attribute.ittr:
logging.debug('method {0} has not attr decorator'.format(attribute_name))
continue
# create product of all the iterators
b = [map(lambda value: (key, value), values)
for key, values in attribute.ittr.iteritems() if values]
products = map(dict, product(*b))
for prod in products:
logging.debug('method product: {0}'.format(prod))
suffix = re.sub(r'\W+', '',
str(prod.values())
.translate(None, "[]'")
.replace(',', '_'))
logging.debug('method suffix: {0}'.format(suffix))
# in case itts passed are empty
if not suffix:
logging.debug('Empty suffix, product: {0}'.format(prod))
continue
new_func_name = attribute_name + '_' + suffix
# combine both product and ittr dict to be added to new method
func_params = dict(attribute.func_dict, **prod)
mirror_func = mcs._attribute_injector(attribute, **func_params)
setattr(mirror_func, 'ittr', prod)
# assign new name and docstring and save back at our class
mirror_func.func_name = new_func_name
mirror_func.func_doc = attribute.func_doc
dct[new_func_name] = mirror_func
# set no test flag to original test method
attribute.__test__ = False
dct['is_multiplied'] = True # mark has been multiplied
return type.__new__(mcs, name, bases, dct)
@classmethod
def _attribute_injector(cls, func, **keywords):
def injector(*fargs, **fkeywords):
# transfer ittr and attr to self when called
self = fargs[0]
for name, value in keywords.iteritems():
setattr(self, name, value)
return func(*fargs, **fkeywords)
# transfers all attr and ittr to newfunc
for name, value in keywords.iteritems():
setattr(injector, name, value)
setattr(injector, 'keywords', keywords)
return injector
| Python | 0.000001 |
d2466f376a19389a8cdc3aeaa070a30edb406b10 | store 'curve_type' in layer's lib | Lib/ufo2ft/filters/cubicToQuadratic.py | Lib/ufo2ft/filters/cubicToQuadratic.py | from __future__ import (
print_function, division, absolute_import, unicode_literals)
from ufo2ft.constants import DEFAULT_LAYER_NAME
from ufo2ft.filters import BaseFilter
from cu2qu.ufo import DEFAULT_MAX_ERR, CURVE_TYPE_LIB_KEY
from cu2qu.pens import Cu2QuPointPen
import logging
logger = logging.getLogger(__name__)
class CubicToQuadraticFilter(BaseFilter):
_kwargs = {
'conversionError': None,
'reverseDirection': True,
'rememberCurveType': False,
}
def set_context(self, font, glyphSet):
ctx = super(CubicToQuadraticFilter, self).set_context(font, glyphSet)
relativeError = self.options.conversionError or DEFAULT_MAX_ERR
ctx.absoluteError = relativeError * font.info.unitsPerEm
ctx.stats = {}
return ctx
def __call__(self, font, glyphSet=None, layerName=DEFAULT_LAYER_NAME):
if self.options.rememberCurveType:
# check first in the global font lib, then in layer lib
for lib in (font.lib, font.layers[layerName].lib):
curve_type = lib.get(CURVE_TYPE_LIB_KEY, "cubic")
if curve_type == "quadratic":
logger.info("Curves already converted to quadratic")
return set()
elif curve_type == "cubic":
pass # keep converting
else:
raise NotImplementedError(curve_type)
modified = super(CubicToQuadraticFilter, self).__call__(
font, glyphSet, layerName
)
if modified:
stats = self.context.stats
logger.info('New spline lengths: %s' % (', '.join(
'%s: %d' % (l, stats[l]) for l in sorted(stats.keys()))))
if self.options.rememberCurveType:
# 'lib' here is the layer's lib, as defined in for loop variable
curve_type = lib.get(CURVE_TYPE_LIB_KEY, "cubic")
if curve_type != "quadratic":
lib[CURVE_TYPE_LIB_KEY] = "quadratic"
return modified
def filter(self, glyph):
if not len(glyph):
return False
pen = Cu2QuPointPen(
glyph.getPointPen(),
self.context.absoluteError,
reverse_direction=self.options.reverseDirection,
stats=self.context.stats)
contours = list(glyph)
glyph.clearContours()
for contour in contours:
contour.drawPoints(pen)
return True
| from __future__ import (
print_function, division, absolute_import, unicode_literals)
from ufo2ft.filters import BaseFilter
from cu2qu.ufo import DEFAULT_MAX_ERR, CURVE_TYPE_LIB_KEY
from cu2qu.pens import Cu2QuPointPen
import logging
logger = logging.getLogger(__name__)
class CubicToQuadraticFilter(BaseFilter):
_kwargs = {
'conversionError': None,
'reverseDirection': True,
'rememberCurveType': False,
}
def set_context(self, font, glyphSet):
ctx = super(CubicToQuadraticFilter, self).set_context(font, glyphSet)
relativeError = self.options.conversionError or DEFAULT_MAX_ERR
ctx.absoluteError = relativeError * font.info.unitsPerEm
ctx.stats = {}
return ctx
def __call__(self, font, glyphSet=None):
if self.options.rememberCurveType:
curve_type = font.lib.get(CURVE_TYPE_LIB_KEY, "cubic")
if curve_type == "quadratic":
logger.info("Curves already converted to quadratic")
return set()
elif curve_type == "cubic":
pass # keep converting
else:
raise NotImplementedError(curve_type)
modified = super(CubicToQuadraticFilter, self).__call__(font, glyphSet)
if modified:
stats = self.context.stats
logger.info('New spline lengths: %s' % (', '.join(
'%s: %d' % (l, stats[l]) for l in sorted(stats.keys()))))
if self.options.rememberCurveType:
curve_type = font.lib.get(CURVE_TYPE_LIB_KEY, "cubic")
if curve_type != "quadratic":
font.lib[CURVE_TYPE_LIB_KEY] = "quadratic"
return modified
def filter(self, glyph):
if not len(glyph):
return False
pen = Cu2QuPointPen(
glyph.getPointPen(),
self.context.absoluteError,
reverse_direction=self.options.reverseDirection,
stats=self.context.stats)
contours = list(glyph)
glyph.clearContours()
for contour in contours:
contour.drawPoints(pen)
return True
| Python | 0 |
b842d9f553fe5c4cbf8273c2c11362b85c0ffbf5 | Change _get_tests to static method. | health_monitor/models.py | health_monitor/models.py | """
Copyright 2017 Gracenote
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 jsonfield import JSONField
from django.db import models
from django.utils import timezone
from . import utils
class Health(models.Model):
uid = models.IntegerField(primary_key=True, db_index=True)
state = JSONField(default={}, blank=True, null=True)
severity = JSONField(default={}, blank=True, null=True)
def __unicode__(self): # For Python 2, use __str__ on Python 3
return unicode(self.uid)
def _calculate_severity(self, g):
"""Return the highest score in state dict."""
test_scores = [1, ]
for t in self.state[g].keys():
if self.state[g][t]['score']:
test_scores.append(self.state[g][t]['score'])
return max(test_scores)
def update_score(self, test, score):
"""Update the health based on the test name and score."""
for group in HealthTest._get_groups(test):
if test in HealthTest._get_tests(group):
if group not in self.state.keys():
self.state[group] = {}
self.state[group] = utils.init_score_dict(self.state[group], test)
self.state[group][test] = utils.update_score_dict(self.state[group][test], score)
self.severity = utils.init_score_dict(self.severity, group)
self.severity[group] = utils.update_score_dict(self.severity[group], self._calculate_severity(group))
self.save()
def delete_test_state(self, test):
"""Delete test state"""
for group in self.state.keys():
if test in self.state[group].keys():
del(self.state[group][test])
self.severity[group] = utils.update_score_dict(self.severity[group], self._calculate_severity(group))
self.save()
class Meta(object):
abstract = True
class HealthTest(models.Model):
uid = models.IntegerField(db_index=True)
time = models.DateTimeField()
test = None
groups = []
health_model = Health
@classmethod
def create(cls, uid, **kwargs):
health_test = cls(uid=uid, time=timezone.now(), **kwargs)
health_test.save()
h, _ = cls.health_model.objects.get_or_create(uid=uid)
h.update_score(test=cls.test, score=cls.get_score(**kwargs))
return health_test
@staticmethod
def _get_tests(group):
return [t.test for t in HealthTest.__subclasses__() if group in t.groups]
@staticmethod
def _get_groups(test):
for t in HealthTest.__subclasses__():
if test == t.test:
return t.groups
return []
@staticmethod
def _get_model(test):
for t in HealthTest.__subclasses__():
if test == t.test:
return t
raise TypeError('test {} does not exist'.format(test))
@classmethod
def get_score(cls, **kwargs):
score = cls.score(**kwargs)
if type(score) != int:
raise TypeError('score() method should return an integer')
else:
return score
class Meta(object):
abstract = True
| """
Copyright 2017 Gracenote
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 jsonfield import JSONField
from django.db import models
from django.utils import timezone
from . import utils
class Health(models.Model):
uid = models.IntegerField(primary_key=True, db_index=True)
state = JSONField(default={}, blank=True, null=True)
severity = JSONField(default={}, blank=True, null=True)
def __unicode__(self): # For Python 2, use __str__ on Python 3
return unicode(self.uid)
def _calculate_severity(self, g):
"""Return the highest score in state dict."""
test_scores = [1, ]
for t in self.state[g].keys():
if self.state[g][t]['score']:
test_scores.append(self.state[g][t]['score'])
return max(test_scores)
def update_score(self, test, score):
"""Update the health based on the test name and score."""
for group in HealthTest._get_groups(test):
if test in HealthTest._get_tests(group):
if group not in self.state.keys():
self.state[group] = {}
self.state[group] = utils.init_score_dict(self.state[group], test)
self.state[group][test] = utils.update_score_dict(self.state[group][test], score)
self.severity = utils.init_score_dict(self.severity, group)
self.severity[group] = utils.update_score_dict(self.severity[group], self._calculate_severity(group))
self.save()
def delete_test_state(self, test):
"""Delete test state"""
for group in self.state.keys():
if test in self.state[group].keys():
del(self.state[group][test])
self.severity[group] = utils.update_score_dict(self.severity[group], self._calculate_severity(group))
self.save()
class Meta(object):
abstract = True
class HealthTest(models.Model):
uid = models.IntegerField(db_index=True)
time = models.DateTimeField()
test = None
groups = []
health_model = Health
@classmethod
def create(cls, uid, **kwargs):
health_test = cls(uid=uid, time=timezone.now(), **kwargs)
health_test.save()
h, _ = cls.health_model.objects.get_or_create(uid=uid)
h.update_score(test=cls.test, score=cls.get_score(**kwargs))
return health_test
@classmethod
def _get_tests(cls, group):
return [t.test for t in HealthTest.__subclasses__() if group in t.groups]
@staticmethod
def _get_groups(test):
for t in HealthTest.__subclasses__():
if test == t.test:
return t.groups
return []
@staticmethod
def _get_model(test):
for t in HealthTest.__subclasses__():
if test == t.test:
return t
raise TypeError('test {} does not exist'.format(test))
@classmethod
def get_score(cls, **kwargs):
score = cls.score(**kwargs)
if type(score) != int:
raise TypeError('score() method should return an integer')
else:
return score
class Meta(object):
abstract = True
| Python | 0 |
2ee4f2d423cf1b3dba9ceed3cd31db91ee0ce86d | Fix variable referenced before assignment | nsone/rest/transport/basic.py | nsone/rest/transport/basic.py | #
# Copyright (c) 2014 NSONE, Inc.
#
# License under The MIT License (MIT). See LICENSE in project root.
#
from __future__ import absolute_import
from nsone.rest.transport.base import TransportBase
from nsone.rest.errors import ResourceException, RateLimitException, \
AuthException
try:
from urllib.request import build_opener, Request, HTTPSHandler
from urllib.error import HTTPError
except ImportError:
from urllib2 import build_opener, Request, HTTPSHandler
from urllib2 import HTTPError
import json
import socket
class BasicTransport(TransportBase):
def __init__(self, config):
TransportBase.__init__(self, config, self.__module__)
self._timeout = self._config.get('timeout', socket._GLOBAL_DEFAULT_TIMEOUT)
def send(self, method, url, headers=None, data=None, files=None,
callback=None, errback=None):
if headers is None:
headers = {}
if files is not None:
# XXX
raise Exception('file uploads not supported in BasicTransport yet')
self._logHeaders(headers)
self._log.debug("%s %s %s" % (method, url, data))
opener = build_opener(HTTPSHandler)
request = Request(url, headers=headers, data=data)
request.get_method = lambda: method
def handleProblem(code, resp, msg):
if errback:
errback((resp, msg))
return
if code == 429:
raise RateLimitException('rate limit exceeded',
resp,
msg)
elif code == 401:
raise AuthException('unauthorized',
resp,
msg)
else:
raise ResourceException('server error',
resp,
msg)
# Handle error and responses the same so we can
# always pass the body to the handleProblem function
try:
resp = opener.open(request, timeout=self._timeout)
except HTTPError as e:
resp = e
except Exception as e:
body = '"Service Unavailable"'
resp = HTTPError(url, 503, body, headers, None)
finally:
body = resp.read()
if resp.code != 200:
handleProblem(resp.code, resp, body)
# TODO make sure json is valid
try:
jsonOut = json.loads(body)
except ValueError:
if errback:
errback(resp)
return
else:
raise ResourceException('invalid json in response',
resp,
body)
if callback:
return callback(jsonOut)
else:
return jsonOut
TransportBase.REGISTRY['basic'] = BasicTransport
| #
# Copyright (c) 2014 NSONE, Inc.
#
# License under The MIT License (MIT). See LICENSE in project root.
#
from __future__ import absolute_import
from nsone.rest.transport.base import TransportBase
from nsone.rest.errors import ResourceException, RateLimitException, \
AuthException
try:
from urllib.request import build_opener, Request, HTTPSHandler
from urllib.error import HTTPError
except ImportError:
from urllib2 import build_opener, Request, HTTPSHandler
from urllib2 import HTTPError
import json
import socket
class BasicTransport(TransportBase):
def __init__(self, config):
TransportBase.__init__(self, config, self.__module__)
self._timeout = self._config.get('timeout', socket._GLOBAL_DEFAULT_TIMEOUT)
def send(self, method, url, headers=None, data=None, files=None,
callback=None, errback=None):
if headers is None:
headers = {}
if files is not None:
# XXX
raise Exception('file uploads not supported in BasicTransport yet')
self._logHeaders(headers)
self._log.debug("%s %s %s" % (method, url, data))
opener = build_opener(HTTPSHandler)
request = Request(url, headers=headers, data=data)
request.get_method = lambda: method
def handleProblem(code, resp, msg):
if errback:
errback((resp, msg))
return
if code == 429:
raise RateLimitException('rate limit exceeded',
resp,
msg)
elif code == 401:
raise AuthException('unauthorized',
resp,
msg)
else:
raise ResourceException('server error',
resp,
msg)
# Handle error and responses the same so we can
# always pass the body to the handleProblem function
try:
resp = opener.open(request, timeout=self._timeout)
except HTTPError as e:
resp = e
body = resp.read()
except Exception as e:
body = '"Service Unavailable"'
resp = HTTPError(url, 503, body, headers, None)
finally:
if resp.code != 200:
handleProblem(resp.code, resp, body)
# TODO make sure json is valid
try:
jsonOut = json.loads(body)
except ValueError:
if errback:
errback(resp)
return
else:
raise ResourceException('invalid json in response',
resp,
body)
if callback:
return callback(jsonOut)
else:
return jsonOut
TransportBase.REGISTRY['basic'] = BasicTransport
| Python | 0.002868 |
5f663eb971542d252186dbf9345ca458dca93c16 | fix file not exist during render file | tpl/tpl.py | tpl/tpl.py | # -*- coding:utf-8 -*-
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import jinja2
from tpl import path
from tpl import errors
class Template(object):
IGNORE_FILES = [
'construct.sh',
'construct.py'
]
def __init__(self, tpl_dir):
self.tpl_dir = tpl_dir
def is_ignored_file(self, file):
file_name = file.split('/')[-1]
if file_name in self.IGNORE_FILES:
return True
return False
def render_file(self, file, context):
env = jinja2.Environment(undefined=jinja2.StrictUndefined)
render_file = file
if '{{' in file and '}}' in file:
render_file = env.from_string(file).render(context)
with open(file, 'r') as fd:
file_content = fd.read()
render_file_content = env.from_string(file_content).render(context)
return render_file, render_file_content
def render_dir(self, dir, context):
if not ('{{' in dir and '}}' in dir):
return dir
env = jinja2.Environment(undefined=jinja2.StrictUndefined)
dir = env.from_string(dir).render(context)
return dir
def render(self, context):
assert isinstance(context)
render_dirs = []
render_files = []
for dir in path.list_dirs(self.tpl_dir):
render_dirs.append(self.render_dir(dir, context))
for file in path.list_files(self.tpl_dir):
if self.is_ignored_file(file):
continue
render_files.append(self.render_file(file, context))
return render_dirs, render_files
| # -*- coding:utf-8 -*-
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import jinja2
from tpl import path
from tpl import errors
class Template(object):
IGNORE_FILES = [
'construct.sh',
'construct.py'
]
def __init__(self, tpl_dir):
self.tpl_dir = tpl_dir
def is_ignored_file(self, file):
file_name = file.split('/')[-1]
if file_name in self.IGNORE_FILES:
return True
return False
def render_file(self, file, context):
env = jinja2.Environment(undefined=jinja2.StrictUndefined)
if '{{' in file and '}}' in file:
file = env.from_string(file).render(context)
with open(file, 'r') as fd:
file_content = fd.read()
file_content = env.from_string(file_content).render(context)
return file, file_content
def render_dir(self, dir, context):
if not ('{{' in dir and '}}' in dir):
return dir
env = jinja2.Environment(undefined=jinja2.StrictUndefined)
dir = env.from_string(dir).render(context)
return dir
def render(self, context):
assert isinstance(context)
render_dirs = []
render_files = []
for dir in path.list_dirs(self.tpl_dir):
render_dirs.append(self.render_dir(dir, context))
for file in path.list_files(self.tpl_dir):
if self.is_ignored_file(file):
continue
render_files.append(self.render_file(file, context))
return render_dirs, render_files
| Python | 0.000001 |
7b385ca9897ab8a7b25966cc54324a4b42596f7d | fix case of no saved lists or items | lists.py | lists.py | # manage list functions
import os
import redis
import json
r = redis.from_url(os.environ.get("REDIS_URL"))
def getLists():
savedLists = r.get('lists')
if savedLists == None:
lists = []
else:
lists = json.loads(savedLists)
savedItems = r.get('items')
if savedItems == None:
items = []
else:
items = json.loads(savedItems)
return True
def putLists()
r.put('lists', json.dumps(lists))
r.pub('items', json.dumps(items))
return True
def createList(list):
getLists()
if (lists.count(list) == 0):
lists.append(list)
items.append([])
putLists()
return True
else:
print('List ' + list + ' already exists')
return False
def deleteList(list)
getLists()
if (lists.count(list) != 0):
items.pop(lists.index(list))
lists.remove(list)
putLists()
return True
else:
print('List ' + list + ' not found')
return False
def addItem(item, list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return False
else:
items[lists.index(list)].append(item)
putLists()
return True
def removeItem(item, list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return False
elif (items[lists.index(list)].count(item) == 0):
print('Item ' + item + ' not found on ' + list + ' list')
return False
else:
items[lists.index(list)].remove(item)
putLists()
return True
def readList(list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return []
else:
return items[lists.index(list)]
| # manage list functions
import os
import redis
import json
r = redis.from_url(os.environ.get("REDIS_URL"))
def getLists():
lists = []
items = []
lists = json.loads(r.get('lists'))
items = json.loads(r.get('items'))
return True
def putLists()
r.put('lists', json.dumps(lists))
r.pub('items', json.dumps(items))
return True
def createList(list):
getLists()
if (lists.count(list) == 0):
lists.append(list)
items.append([])
putLists()
return True
else:
print('List ' + list + ' already exists')
return False
def deleteList(list)
getLists()
if (lists.count(list) != 0):
items.pop(lists.index(list))
lists.remove(list)
putLists()
return True
else:
print('List ' + list + ' not found')
return False
def addItem(item, list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return False
else:
items[lists.index(list)].append(item)
putLists()
return True
def removeItem(item, list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return False
elif (items[lists.index(list)].count(item) == 0):
print('Item ' + item + ' not found on ' + list + ' list')
return False
else:
items[lists.index(list)].remove(item)
putLists()
return True
def readList(list):
getLists()
if (lists.count(list) == 0):
print('List ' + list + ' not found')
return []
else:
return items[lists.index(list)]
| Python | 0.00001 |
2a08d3154992b5f0633d7cd2ca1bbfc7ecd63f69 | Fix to allow version number to be imported without dependencies being installed. | email_extras/__init__.py | email_extras/__init__.py |
from email_extras.settings import USE_GNUPG
__version__ = "0.1.0"
if USE_GNUPG:
try:
import gnupg
except ImportError:
try:
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured, "Could not import gnupg"
except ImportError:
pass
|
from django.core.exceptions import ImproperlyConfigured
from email_extras.settings import USE_GNUPG
__version__ = "0.1.0"
if USE_GNUPG:
try:
import gnupg
except ImportError:
raise ImproperlyConfigured, "Could not import gnupg"
| Python | 0 |
b39518482da1d3e064cdbc34490e4a9924f6d5f1 | Add a test for vectorized call | quantecon/tests/test_ecdf.py | quantecon/tests/test_ecdf.py | """
Tests for ecdf.py
"""
import unittest
import numpy as np
from quantecon import ECDF
class TestECDF(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.obs = np.random.rand(40) # observations defining dist
cls.ecdf = ECDF(cls.obs)
def test_call_high(self):
"ecdf: x above all obs give 1.0"
# all of self.obs <= 1 so ecdf(1.1) should be 1
self.assertAlmostEqual(self.ecdf(1.1), 1.0)
def test_call_low(self):
"ecdf: x below all obs give 0.0"
# all of self.obs <= 1 so ecdf(1.1) should be 1
self.assertAlmostEqual(self.ecdf(-0.1), 0.0)
def test_ascending(self):
"ecdf: larger values should return F(x) at least as big"
x = np.random.rand()
F_1 = self.ecdf(x)
F_2 = self.ecdf(1.1 * x)
self.assertGreaterEqual(F_2, F_1)
def test_vectorized(self):
"ecdf: testing vectorized __call__ method"
t = np.linspace(-1, 1, 100)
self.assertEqual(t.shape, self.ecdf(t).shape)
t = np.linspace(-1, 1, 100).reshape(2, 2, 25)
self.assertEqual(t.shape, self.ecdf(t).shape)
| """
Tests for ecdf.py
"""
import unittest
import numpy as np
from quantecon import ECDF
class TestECDF(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.obs = np.random.rand(40) # observations defining dist
cls.ecdf = ECDF(cls.obs)
def test_call_high(self):
"ecdf: x above all obs give 1.0"
# all of self.obs <= 1 so ecdf(1.1) should be 1
self.assertAlmostEqual(self.ecdf(1.1), 1.0)
def test_call_low(self):
"ecdf: x below all obs give 0.0"
# all of self.obs <= 1 so ecdf(1.1) should be 1
self.assertAlmostEqual(self.ecdf(-0.1), 0.0)
def test_ascending(self):
"ecdf: larger values should return F(x) at least as big"
x = np.random.rand()
F_1 = self.ecdf(x)
F_2 = self.ecdf(1.1 * x)
self.assertGreaterEqual(F_2, F_1)
| Python | 0 |
e36192babd239366d51d1ea7cdfab94c06791fe7 | Test assertElementPresents return function | functional_tests/test_base.py | functional_tests/test_base.py | # -*- coding: utf-8 -*-
from .base import FunctionalTestCase
import unittest
from unittest import mock
class TestBaseFuctionalTest(unittest.TestCase):
def test_assertelementpresent_can_find_string(self):
e = [mock.Mock(text='test')]
ft = FunctionalTestCase()
ft.assertElementPresent(e, 'test')
def test_assertelementpresent_raises_when_string_not_found(self):
e = [mock.Mock(text='some string')]
ft = FunctionalTestCase()
with self.assertRaises(AssertionError):
ft.assertElementPresent(e, 'test')
def test_assertelementpresent_returns_element_found(self):
e = [mock.Mock(text='test'), mock.Mock(text='some string')]
ft = FunctionalTestCase()
ret = ft.assertElementPresent(e, 'test')
self.assertEquals(e[0], ret)
| # -*- coding: utf-8 -*-
from .base import FunctionalTestCase
import unittest
from unittest import mock
class TestBaseFuctionalTest(unittest.TestCase):
def test_assertelementpresent_can_find_string(self):
e = [mock.Mock(text='test')]
ft = FunctionalTestCase()
ft.assertElementPresent(e, 'test')
def test_assertelementpresent_raises_when_string_not_found(self):
e = [mock.Mock(text='some string')]
ft = FunctionalTestCase()
with self.assertRaises(AssertionError):
ft.assertElementPresent(e, 'test')
| Python | 0.000002 |
472c22a83e9e3982e5b6705757f79fba3b32f3e6 | Set path dependency with context to development and deployment | hooks/common.py | hooks/common.py | import os
import sys
import urllib2
# Add charmhelpers to the system path.
try:
sys.path.insert(0, os.path.abspath(os.path.join(os.environ['CHARM_DIR'],
'lib')))
except:
sys.path.insert(0, os.path.abspath(os.path.join('..', 'lib')))
from charmhelpers.core.hookenv import (
log,
config,
)
from charmhelpers.core.host import (
mkdir,
)
from charmhelpers.fetch import (
apt_install,
apt_update,
)
def sanity_check():
if not config()['canonical_domain']:
log("No Canonical Domain specified - Aborting until configured")
# It's reasonable to assume we're not doing anything useful at this
# point, as we are unconfigured. Abort doing *anything*
return False
return True
# ###########
# Environment Probe / Modifications
# ###########
# Create Configuration Directories for local Bind9 Server
def make_bind_store():
mkdir('/etc/bind')
mkdir('/etc/bind/zones')
# Parse existing nameservers from resolv.conf
def existing_nameservers():
dns_servers = []
with open('/etc/resolv.conf') as f:
contents = f.readlines()
print contents
for line in contents:
if line.find('nameserver') != -1:
dns_servers.append(line.replace('nameserver ', '').rstrip())
return dns_servers
# this is kind of arbitrary, attempt to connect to a google ip address.
# This won't be the best solution, but i'm open to ideas on how to improve
# 'onlineability' checking.
def am_i_online():
try:
urllib2.urlopen('http://74.125.228.100', timeout=1)
return True
except urllib2.URLError:
pass
return False
# ###########
# BIND tasks
# ###########
def install():
sanity_check()
log("Preparing for BIND installation")
apt_update(fatal=True)
apt_install(packages=[
'bind9',
'dnsutils',
'python-dnspython'
], fatal=True)
def install_bind():
sanity_check()
log("Preparing for BIND installation")
apt_update(fatal=True)
apt_install(packages=[
'bind9',
'dnsutils',
'python-dnspython'
], fatal=True)
| import os
import sys
import urllib2
# Add charmhelpers to the system path.
sys.path.insert(0, os.path.abspath(os.path.join('..', 'lib')))
from charmhelpers.core.hookenv import (
log,
config,
)
from charmhelpers.core.host import (
mkdir,
)
from charmhelpers.fetch import (
apt_install,
apt_update,
)
def sanity_check():
if not config()['canonical_domain']:
log("No Canonical Domain specified - Aborting until configured")
# It's reasonable to assume we're not doing anything useful at this
# point, as we are unconfigured. Abort doing *anything*
return False
return True
# ###########
# Environment Probe / Modifications
# ###########
# Create Configuration Directories for local Bind9 Server
def make_bind_store():
mkdir('/etc/bind')
mkdir('/etc/bind/zones')
# Parse existing nameservers from resolv.conf
def existing_nameservers():
dns_servers = []
with open('/etc/resolv.conf') as f:
contents = f.readlines()
print contents
for line in contents:
if line.find('nameserver') != -1:
dns_servers.append(line.replace('nameserver ', '').rstrip())
return dns_servers
# this is kind of arbitrary, attempt to connect to a google ip address.
# This won't be the best solution, but i'm open to ideas on how to improve
# 'onlineability' checking.
def am_i_online():
try:
urllib2.urlopen('http://74.125.228.100', timeout=1)
return True
except urllib2.URLError:
pass
return False
# ###########
# BIND tasks
# ###########
def install():
sanity_check()
log("Preparing for BIND installation")
apt_update(fatal=True)
apt_install(packages=[
'bind9',
'dnsutils',
'python-dnspython'
], fatal=True)
def install_bind():
sanity_check()
log("Preparing for BIND installation")
apt_update(fatal=True)
apt_install(packages=[
'bind9',
'dnsutils',
'python-dnspython'
], fatal=True)
| Python | 0 |
a2b6cef1fc6dee679407d61312a23f96c3e99cda | Use a plain list of url instances for the tests urls too | oauth2_provider/tests/urls.py | oauth2_provider/tests/urls.py | from django.conf.urls import include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = (
url(r'^admin/', include(admin.site.urls)),
url(r'^o/', include('oauth2_provider.urls', namespace='oauth2_provider')),
)
| from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns(
'',
url(r'^admin/', include(admin.site.urls)),
url(r'^o/', include('oauth2_provider.urls', namespace='oauth2_provider')),
)
| Python | 0 |
aaf243646eccebea2e1d764d7de58c40c279830c | test info | hostend/main.py | hostend/main.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import sys
sys.path.append('..')
from tornado.web import Application
import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.autoreload
from tornado.options import define, options
from hostend.controller import *
from lib.utils import Host
from proxy import *
import docker
import json
from handlers import *
config = json.load(open('config.json','r'))
controller = Controller()
controller.reportUrl = config.get('reportUrl')
controller.requestUrl = config.get('requestUrl')
host = Host.currentHost('',switchInterface=config['switchName'],transportInterface=config['transportInterface'])
data = controller.request('getHostId',[host.mac,host.transportIP])
if 'uuid' in data :
host.uuid = data['uuid']
print 'my host id is : %s'%host.uuid
define("port", default=8000, help="run on the given port", type=int)
class Application(tornado.web.Application):
def __init__(self):
handlers = [
(r'/createContainer',CreateContainerHandler)
]
settings = {
'template_path': 'templates',
'debug': True,
'cookie_secret' : "dfaew989q2kejczo8u8923e400ialsjdf",
'static_path': 'static'
}
self.host = host
self.controller = controller
self.containerProxy = DockerProxy(docker.Client('unix://var/run/docker.sock'),self.host,self.controller)
tornado.web.Application.__init__(self, handlers, **settings)
if __name__ == "__main__":
tornado.options.parse_command_line()
app = Application()
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import sys
sys.path.append('..')
from tornado.web import Application
import tornado.ioloop
import tornado.options
import tornado.httpserver
import tornado.autoreload
from tornado.options import define, options
from hostend.controller import *
from lib.utils import Host
from proxy import *
import docker
import json
from handlers import *
config = json.load(open('config.json','r'))
controller = Controller()
controller.reportUrl = config.get('reportUrl')
controller.requestUrl = config.get('requestUrl')
host = Host.currentHost('',switchInterface=config['switchName'],transportInterface=config['transportInterface'])
data = controller.request('getHostId',[host.mac,host.transportIP])
if 'uuid' in data :
host.uuid = data['uuid']
define("port", default=8000, help="run on the given port", type=int)
class Application(tornado.web.Application):
def __init__(self):
handlers = [
(r'/createContainer',CreateContainerHandler)
]
settings = {
'template_path': 'templates',
'debug': True,
'cookie_secret' : "dfaew989q2kejczo8u8923e400ialsjdf",
'static_path': 'static'
}
self.host = host
self.controller = controller
self.containerProxy = DockerProxy(docker.Client('unix://var/run/docker.sock'),self.host,self.controller)
tornado.web.Application.__init__(self, handlers, **settings)
if __name__ == "__main__":
tornado.options.parse_command_line()
app = Application()
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
| Python | 0.000001 |
0fbfef27d35cea23ad0e20fd2c9df3e8a4a046cb | Fix GCF region tags (#1827) | functions/log/main.py | functions/log/main.py | # Copyright 2018 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.
# [START functions_log_stackdriver]
import base64
import json
# [END functions_log_stackdriver]
# [START functions_log_helloworld]
import logging
# [END functions_log_helloworld]
# [START functions_log_retrieve]
import os
# [END functions_log_retrieve]
# [START functions_log_retrieve]
import google.cloud.logging as cloud_logging
# [END functions_log_retrieve]
# [START functions_log_helloworld]
def hello_world(data, context):
"""Background Cloud Function.
Args:
data (dict): The dictionary with data specific to the given event.
context (google.cloud.functions.Context): The event metadata.
"""
print('Hello, stdout!')
logging.warn('Hello, logging handler!')
# [END functions_log_helloworld]
# [START functions_log_retrieve]
cloud_client = cloud_logging.Client()
log_name = 'cloudfunctions.googleapis.com%2Fcloud-functions'
cloud_logger = cloud_client.logger(log_name.format(os.getenv('GCP_PROJECT')))
def get_log_entries(request):
"""
HTTP Cloud Function that displays log entries from Cloud Functions.
Args:
request (flask.Request): The request object.
Returns:
The response text, or any set of values that can be turned into a
Response object using `make_response`
<http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
"""
""""""
all_entries = cloud_logger.list_entries(page_size=10)
entries = next(all_entries.pages)
for entry in entries:
timestamp = entry.timestamp.isoformat()
print('* {}: {}'.format
(timestamp, entry.payload))
return 'Done!'
# [END functions_log_retrieve]
# [START functions_log_stackdriver]
def process_log_entry(data, context):
data_buffer = base64.b64decode(data['data'])
log_entry = json.loads(data_buffer)['protoPayload']
print(f"Method: {log_entry['methodName']}")
print(f"Resource: {log_entry['resourceName']}")
print(f"Initiator: {log_entry['authenticationInfo']['principalEmail']}")
# [END functions_log_stackdriver]
| # Copyright 2018 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.
# [START functions_log_bigquery_stackdriver]
import base64
import json
# [END functions_log_bigquery_stackdriver]
# [START functions_log_helloworld]
import logging
# [END functions_log_helloworld]
# [START functions_log_retrieve]
import os
# [END functions_log_retrieve]
# [START functions_logs_retrieve]
import google.cloud.logging as cloud_logging
# [END functions_logs_retrieve]
# [START functions_log_helloworld]
def hello_world(data, context):
"""Background Cloud Function.
Args:
data (dict): The dictionary with data specific to the given event.
context (google.cloud.functions.Context): The event metadata.
"""
print('Hello, stdout!')
logging.warn('Hello, logging handler!')
# [END functions_log_helloworld]
# [START functions_log_retrieve]
cloud_client = cloud_logging.Client()
log_name = 'cloudfunctions.googleapis.com%2Fcloud-functions'
cloud_logger = cloud_client.logger(log_name.format(os.getenv('GCP_PROJECT')))
def get_log_entries(request):
"""
HTTP Cloud Function that displays log entries from Cloud Functions.
Args:
request (flask.Request): The request object.
Returns:
The response text, or any set of values that can be turned into a
Response object using `make_response`
<http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
"""
""""""
all_entries = cloud_logger.list_entries(page_size=10)
entries = next(all_entries.pages)
for entry in entries:
timestamp = entry.timestamp.isoformat()
print('* {}: {}'.format
(timestamp, entry.payload))
return 'Done!'
# [END functions_log_retrieve]
# [START functions_log_stackdriver]
def process_log_entry(data, context):
data_buffer = base64.b64decode(data['data'])
log_entry = json.loads(data_buffer)['protoPayload']
print(f"Method: {log_entry['methodName']}")
print(f"Resource: {log_entry['resourceName']}")
print(f"Initiator: {log_entry['authenticationInfo']['principalEmail']}")
# [END functions_log_stackdriver]
| Python | 0 |
8d56c42dd3a721a477fa1333c1d979f4002e7cc1 | Simplify importer paths after dockerization | labonneboite/importer/conf/lbbdev.py | labonneboite/importer/conf/lbbdev.py | import os
# --- importer input directory of DPAE and ETABLISSEMENT exports
INPUT_SOURCE_FOLDER = '/srv/lbb/data'
# --- job 1/8 & 2/8 : check_etablissements & extract_etablissements
JENKINS_ETAB_PROPERTIES_FILENAME = os.path.join(os.environ["WORKSPACE"], "properties.jenkins")
MINIMUM_OFFICES_TO_BE_EXTRACTED_PER_DEPARTEMENT = 10000
# --- job 3/8 & 4/8 : check_dpae & extract_dpae
JENKINS_DPAE_PROPERTIES_FILENAME = os.path.join(os.environ["WORKSPACE"], "properties_dpae.jenkins")
MAXIMUM_ZIPCODE_ERRORS = 100
MAXIMUM_INVALID_ROWS = 100
# --- job 5/8 : compute_scores
SCORE_COEFFICIENT_OF_VARIATION_MAX = 2.0
RMSE_MAX = 1500 # On 2017.03.15 departement 52 reached RMSE=1141
HIGH_SCORE_COMPANIES_DIFF_MAX = 70
# --- job 6/8 : validate_scores
MINIMUM_OFFICES_PER_DEPARTEMENT_FOR_DPAE = 500
MINIMUM_OFFICES_PER_DEPARTEMENT_FOR_ALTERNANCE = 0
# --- job 8/8 : populate_flags
| import os
# --- importer input directory of DPAE and ETABLISSEMENT exports
INPUT_SOURCE_FOLDER = '/srv/lbb/data'
# --- job 1/8 & 2/8 : check_etablissements & extract_etablissements
JENKINS_ETAB_PROPERTIES_FILENAME = os.path.join(os.environ["WORKSPACE"], "properties.jenkins")
MINIMUM_OFFICES_TO_BE_EXTRACTED_PER_DEPARTEMENT = 10000
# --- job 3/8 & 4/8 : check_dpae & extract_dpae
JENKINS_DPAE_PROPERTIES_FILENAME = os.path.join(os.environ["WORKSPACE"], "properties_dpae.jenkins")
MAXIMUM_ZIPCODE_ERRORS = 100
MAXIMUM_INVALID_ROWS = 100
# --- job 5/8 : compute_scores
SCORE_COEFFICIENT_OF_VARIATION_MAX = 2.0
RMSE_MAX = 1500 # On 2017.03.15 departement 52 reached RMSE=1141
HIGH_SCORE_COMPANIES_DIFF_MAX = 70
# --- job 6/8 : validate_scores
MINIMUM_OFFICES_PER_DEPARTEMENT_FOR_DPAE = 500
MINIMUM_OFFICES_PER_DEPARTEMENT_FOR_ALTERNANCE = 0
# --- job 8/8 : populate_flags
BACKUP_OUTPUT_FOLDER = '/srv/lbb/backups/outputs'
BACKUP_FOLDER = '/srv/lbb/backups'
| Python | 0.000009 |
f1c270f2145cf1f48a0207696cb4f6e9592af357 | Correct db `NAME`, use in-memory database for testing | NTHU_Course/settings/testing_sqlite.py | NTHU_Course/settings/testing_sqlite.py | '''
A configuration for testing in travis CI with sqlite3
'''
from .default import * # noqa
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
# https://docs.djangoproject.com/en/1.10/topics/testing/overview/#the-test-database
# django uses in memory database for testing
'NAME': ':memory:'
}
}
| '''
A configuration for testing in travis CI with sqlite3
'''
from .default import * # noqa
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
# https://docs.djangoproject.com/en/1.10/topics/testing/overview/#the-test-database
# django uses in memory database for testing
'NAME': 'test_sqlite'
}
}
| Python | 0.000001 |
34f3d762f608c3ea3fd12cded38dc3853d36545f | Update vouchers.py | 2014-2015/B4-vouchers/vouchers.py | 2014-2015/B4-vouchers/vouchers.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright 2014 Fabian M.
#
# 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.
vouchers = [1, 2, 3, 5, 8, 9, 18, 19, 46, 154, 313]
def main():
for b in range(1, max(vouchers)):
# Amount can be created with one voucher.
if b in vouchers:
continue
bins = []
ws = sorted(vouchers, reverse=True)
for w in ws:
for x in bins:
if sum(x) + w <= b:
x.append(w)
w = None
break
if w != None:
bins.append([w])
r = list(map(sum, bins))
if b not in list(map(sum, bins)):
print(b)
return
main()
| vouchers = [1, 2, 3, 5, 8, 9, 18, 19, 46, 154, 313]
def main():
for b in range(1, max(vouchers)):
# Amount can be created with one voucher.
if b in vouchers:
continue
bins = []
ws = sorted(vouchers, reverse=True)
for w in ws:
for x in bins:
if sum(x) + w <= b:
x.append(w)
w = None
break
if w != None:
bins.append([w])
r = list(map(sum, bins))
if b not in list(map(sum, bins)):
print(b)
return
main()
| Python | 0 |
241376f76d4175c98c8226998832b8054697504c | Fix xpath expression for tomorrows forecast | app/jobs/yr.py | app/jobs/yr.py | #!/usr/bin/env python
import requests
from datetime import datetime, timedelta
from jobs import AbstractJob
from lxml import etree
class Yr(AbstractJob):
def __init__(self, conf):
self.url = conf['url']
self.interval = conf['interval']
def _parse_tree(self, tree, tabular_xpath=None):
if tabular_xpath is None:
tabular = tree.xpath('/weatherdata/forecast/tabular/time[1]').pop()
data_root = tree.xpath(
'/weatherdata/observations/weatherstation[1]').pop()
else:
tabular = tree.xpath(tabular_xpath).pop()
data_root = tabular
windSpeed = data_root.xpath('windSpeed').pop()
return {
'location': tree.xpath('/weatherdata/location/name').pop().text,
'temperature': data_root.xpath('temperature').pop().get('value'),
'description': tabular.xpath('symbol').pop().get('name'),
'wind': {
'speed': windSpeed.get('mps'),
'description': windSpeed.get('name'),
'direction': data_root.xpath('windDirection').pop().get('name')
}
}
def _parse(self, xml):
tree = etree.fromstring(xml)
data = self._parse_tree(tree)
tomorrow = datetime.now().date() + timedelta(days=1)
xpath = ('/weatherdata/forecast/tabular/time[@period=2 and'
' starts-with(@from, "%s")]') % (tomorrow.strftime('%F'),)
data.update({'tomorrow': self._parse_tree(tree, xpath)})
return data
def get(self):
r = requests.get(self.url)
if r.status_code == 200 and len(r.content) > 0:
return self._parse(r.content)
return {}
| #!/usr/bin/env python
import requests
from jobs import AbstractJob
from lxml import etree
class Yr(AbstractJob):
def __init__(self, conf):
self.url = conf['url']
self.interval = conf['interval']
def _parse_tree(self, tree, tabular_xpath=None):
if tabular_xpath is None:
tabular = tree.xpath('/weatherdata/forecast/tabular/time[1]').pop()
data_root = tree.xpath(
'/weatherdata/observations/weatherstation[1]').pop()
else:
tabular = tree.xpath(tabular_xpath).pop()
data_root = tabular
windSpeed = data_root.xpath('windSpeed').pop()
return {
'location': tree.xpath('/weatherdata/location/name').pop().text,
'temperature': data_root.xpath('temperature').pop().get('value'),
'description': tabular.xpath('symbol').pop().get('name'),
'wind': {
'speed': windSpeed.get('mps'),
'description': windSpeed.get('name'),
'direction': data_root.xpath('windDirection').pop().get('name')
}
}
def _parse(self, xml):
tree = etree.fromstring(xml)
data = self._parse_tree(tree)
data.update({'tomorrow': self._parse_tree(
tree, '/weatherdata/forecast/tabular/time[3]')})
return data
def get(self):
r = requests.get(self.url)
if r.status_code == 200 and len(r.content) > 0:
return self._parse(r.content)
return {}
| Python | 0.000131 |
b6b522bbdde24f0e6eab0e7a91830171bcac63a5 | Add logout url | genevieve/urls.py | genevieve/urls.py | from django.conf import settings
from django.conf.urls import patterns, include, url
from django.conf.urls.static import static
from django.contrib import admin
from django.contrib.auth import views as auth_views
from .views import UserCreateView
admin.autodiscover()
urlpatterns = patterns('',
url(r'^admin/', include(admin.site.urls)),
)
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'genevieve.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
(r'^file_process/', include('file_process.urls')),
url(r'^accounts/signup/$', UserCreateView.as_view()),
url(r'^accounts/login/$', auth_views.login,
{'template_name': 'login.html',
'extra_context': {'next': '/file_process'}}, name='auth_login'),
url(r'^accounts/logout/$', auth_views.logout, {'next_page': '/file_process'},
name='auth_logout'),
) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
| from django.conf import settings
from django.conf.urls import patterns, include, url
from django.conf.urls.static import static
from django.contrib import admin
from django.contrib.auth import views as auth_views
from .views import UserCreateView
admin.autodiscover()
urlpatterns = patterns('',
url(r'^admin/', include(admin.site.urls)),
)
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'genevieve.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
(r'^file_process/', include('file_process.urls')),
url(r'^accounts/signup/$', UserCreateView.as_view()),
url(r'^accounts/login/$', auth_views.login,
{'template_name': 'login.html',
'extra_context': {'next': '/file_process'}}, name='auth_login'),
) + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
| Python | 0.000003 |
ba2161f6adf5a0e0782e322371d7071ca79d02e3 | Update tornado for mypy | gidgethub/tornado.py | gidgethub/tornado.py | from typing import Mapping, Optional, Tuple
from tornado import gen
from tornado import httpclient
from . import abc as gh_abc
class GitHubAPI(gh_abc.GitHubAPI):
async def _request(self, method: str, url: str, headers: Mapping[str, str],
body: bytes = b'') -> Tuple[int, Mapping[str, str], bytes]:
"""Make an HTTP request."""
if method == "GET" and not body:
real_body = None
else:
real_body = body
request = httpclient.HTTPRequest(url, method, headers, real_body)
# Since Tornado has designed AsyncHTTPClient to be a singleton, there's
# no reason not to simply instantiate it every time.
client = httpclient.AsyncHTTPClient()
response = await client.fetch(request, raise_error=False)
return response.code, response.headers, response.body
async def sleep(self, seconds: float) -> None:
"""Sleep for the specified number of seconds."""
await gen.sleep(seconds)
| from typing import Mapping, Optional, Tuple
from tornado import gen
from tornado import httpclient
from . import abc as gh_abc
class GitHubAPI(gh_abc.GitHubAPI):
async def _request(self, method: str, url: str, headers: Mapping,
body: bytes = b'') -> Tuple[int, Mapping, bytes]:
"""Make an HTTP request."""
if method == "GET" and not body:
real_body = None
else:
real_body = body
request = httpclient.HTTPRequest(url, method, headers, real_body)
# Since Tornado has designed AsyncHTTPClient to be a singleton, there's
# no reason not to simply instantiate it every time.
client = httpclient.AsyncHTTPClient()
response = await client.fetch(request, raise_error=False)
return response.code, response.headers, response.body
async def sleep(self, seconds: float) -> None:
"""Sleep for the specified number of seconds."""
await gen.sleep(seconds)
| Python | 0 |
ad56d5aa6b2359098c4ed6bf9cd37cb58613a372 | Update github3.repos.tag for consistency | github3/repos/tag.py | github3/repos/tag.py | # -*- coding: utf-8 -*-
"""This module contains the RepoTag object for GitHub's tag API."""
from __future__ import unicode_literals
from . import commit
from .. import models
class RepoTag(models.GitHubCore):
"""Representation of a tag made on a GitHub repository.
.. note::
This is distinct from :class:`~github3.git.Tag`. This object
has information specific to a tag on a *GitHub* repository.
That includes URLs to the tarball and zipball files auto-generated
by GitHub.
See also: http://developer.github.com/v3/repos/#list-tags
This object has the following attributes:
.. attribute:: commit
.. versionchanged:: 1.0.0
This attribute used to be a two item dictionary.
A :class:`~github3.repos.commit.MiniCommit` object representing the
commit this tag references.
.. attribute:: name
The name of this tag, e.g., ``v1.0.0``.
.. attribute:: tarball_url
The URL for the tarball file generated by GitHub for this tag.
.. attribute:: zipball_url
The URL for the zipball file generated by GitHub for this tag.
"""
def _update_attributes(self, tag):
self.commit = commit.MiniCommit(tag['commit'], self)
self.name = tag['name']
self.tarball_url = tag['tarball_url']
self.zipball_url = tag['zipball_url']
def _repr(self):
return '<Repository Tag [{0}]>'.format(self)
def __str__(self):
return self.name
| # -*- coding: utf-8 -*-
"""
github3.repos.tag
=================
This module contains the RepoTag object for GitHub's tag API.
"""
from __future__ import unicode_literals
from ..models import GitHubCore
class RepoTag(GitHubCore):
"""The :class:`RepoTag <RepoTag>` object. This stores the information
representing a tag that was created on a repository.
See also: http://developer.github.com/v3/repos/#list-tags
"""
def _update_attributes(self, tag):
#: Name of the tag.
self.name = self._get_attribute(tag, 'name')
#: URL for the GitHub generated zipball associated with the tag.
self.zipball_url = self._get_attribute(tag, 'zipball_url')
#: URL for the GitHub generated tarball associated with the tag.
self.tarball_url = self._get_attribute(tag, 'tarball_url')
#: Dictionary containing the SHA and URL of the commit.
self.commit = self._get_attribute(tag, 'commit', {})
def _repr(self):
return '<Repository Tag [{0}]>'.format(self)
def __str__(self):
return self.name
| Python | 0 |
73f3c743139927a049c5e733f98e1fcb8125721a | Update release version | gdaltools/metadata.py | gdaltools/metadata.py | # -*- coding: utf-8 -*-
"""Project metadata
Information describing the project.
"""
# The package name, which is also the "UNIX name" for the project.
package = 'pygdaltools'
project = 'pygdaltools'
project_no_spaces = project.replace(' ', '')
version = '0.3'
description = """Python wrapper for Gdal/OGR command line tools"""
authors = ['Cesar Martinez Izquierdo - SCOLAB']
authors_string = ', '.join(authors)
emails = []
license = 'AGPL3'
copyright = '2016 ' + authors_string
url = 'https://github.com/scolab-dot-eu/pygdaltools'
| # -*- coding: utf-8 -*-
"""Project metadata
Information describing the project.
"""
# The package name, which is also the "UNIX name" for the project.
package = 'pygdaltools'
project = 'pygdaltools'
project_no_spaces = project.replace(' ', '')
version = '0.2'
description = """Python wrapper for Gdal/OGR command line tools"""
authors = ['Cesar Martinez Izquierdo - SCOLAB']
authors_string = ', '.join(authors)
emails = []
license = 'AGPL3'
copyright = '2016 ' + authors_string
url = 'https://github.com/scolab-dot-eu/pygdaltools'
| Python | 0 |
2c0dbf04f04b686cac79e40791c3ed298618dd07 | add more info on process | gen-gallery-images.py | gen-gallery-images.py | '''Generates small and medium gallery images from a set of large originals. Some maps will be tall, some wide, some square so we want to simply maintain the ratio and resize down to a set maximum.
Original images need to be downloaded to the large image path below. They are accessible in this Dropbox folder
https://www.dropbox.com/sh/z9fjbfquwd1t5st/AAAxV22dpleDodnxJqiertt0a?dl=0
Once large, medium, and small images are in place the folders are copied into the foss4g Wordpress theme, in the uploads/mapgallery folder where the images are served from to the map gallery page. See the map gallery page template.
'''
from wand.image import Image
from os import listdir
from os.path import isfile, join
small_size = 400
med_size = 1280
img_path = "/Users/twelch/src/foss4g2014-wordpress/uploads/mapgallery/"
large_path = img_path+"large/"
med_path = img_path+"medium/"
small_path = img_path+"small/"
#Get list of files in directory
img_files = [ f for f in listdir(large_path) if isfile(join(large_path,f)) ]
print "Looking for images in: " + img_path
print "Found the following: " + str(img_files)
for f in img_files:
if f.startswith("."):
print "Not an image file: " + str(f)
else:
print "Processing image: "+f
#Create image objects for small and medium using original large
mi = Image(filename=join(large_path,f))
si = mi.clone()
print 'Original: '+str(mi.width)+'x'+str(mi.height)
#Resize maintaining aspect ratio
mi.transform(resize=str(med_size)+'x'+str(med_size)+'>')
print 'Medium: '+str(mi.width)+'x'+str(mi.height)
si.transform(resize=str(small_size)+'x'+str(small_size)+'>')
print 'Small: '+str(si.width)+'x'+str(si.height)
#Convert to JPEG if necessary and save as new file
mf = join(med_path,f)
if mi.format != 'JPEG':
mi.convert('jpeg')
mi.save(filename=mf)
sf = join(small_path,f)
if si.format != 'JPEG':
si.convert('jpeg')
si.save(filename=sf)
| '''Generates small and medium gallery images from a set of large originals. Some maps will be tall, some wide, some square so we want to simply maintain the ratio and resize down to a set maximum.
Original images need to be downloaded to the large path below. They are accessible in this Dropbox folder
https://www.dropbox.com/sh/z9fjbfquwd1t5st/AAAxV22dpleDodnxJqiertt0a?dl=0
'''
from wand.image import Image
from os import listdir
from os.path import isfile, join
small_size = 400
med_size = 1280
img_path = "/Users/twelch/src/foss4g2014-wordpress/uploads/mapgallery/"
large_path = img_path+"large/"
med_path = img_path+"medium/"
small_path = img_path+"small/"
#Get list of files in directory
img_files = [ f for f in listdir(large_path) if isfile(join(large_path,f)) ]
print "Looking for images in: " + img_path
print "Found the following: " + str(img_files)
for f in img_files:
if f.startswith("."):
print "Not an image file: " + str(f)
else:
print "Processing image: "+f
#Create image objects for small and medium using original large
mi = Image(filename=join(large_path,f))
si = mi.clone()
print 'Original: '+str(mi.width)+'x'+str(mi.height)
#Resize maintaining aspect ratio
mi.transform(resize=str(med_size)+'x'+str(med_size)+'>')
print 'Medium: '+str(mi.width)+'x'+str(mi.height)
si.transform(resize=str(small_size)+'x'+str(small_size)+'>')
print 'Small: '+str(si.width)+'x'+str(si.height)
#Convert to JPEG if necessary and save as new file
mf = join(med_path,f)
if mi.format != 'JPEG':
mi.convert('jpeg')
mi.save(filename=mf)
sf = join(small_path,f)
if si.format != 'JPEG':
si.convert('jpeg')
si.save(filename=sf)
| Python | 0 |
2fcca753e2877d21e158d5e4a3923e1d22e61608 | Add mask A to causal atrous conv1d (WIP) | eva/layers/causal_atrous_convolution1d.py | eva/layers/causal_atrous_convolution1d.py | import keras.backend as K
from keras.layers import AtrousConvolution1D
from keras.utils.np_utils import conv_output_length
class CausalAtrousConvolution1D(AtrousConvolution1D):
def __init__(self, *args, mask_type='B', **kwargs):
super().__init__(*args, **kwargs)
if self.border_mode != 'valid':
raise ValueError("Causal mode dictates border_mode=valid.")
self.length = self.atrous_rate * (self.filter_length - 1)
# XXX debug.
if mask_type == 'A':
self.length = 3
def get_output_shape_for(self, input_shape):
length = conv_output_length(input_shape[1] + self.length,
self.filter_length,
self.border_mode,
self.subsample[0],
dilation=self.atrous_rate)
return (input_shape[0], length, self.nb_filter)
def call(self, x, mask=None):
return super().call(K.asymmetric_temporal_padding(x, self.length, 0), mask)
| import keras.backend as K
from keras.layers import AtrousConvolution1D
from keras.utils.np_utils import conv_output_length
class CausalAtrousConvolution1D(AtrousConvolution1D):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.border_mode != 'valid':
raise ValueError("Causal mode dictates border_mode=valid.")
self.length = self.atrous_rate * (self.filter_length - 1)
def get_output_shape_for(self, input_shape):
length = conv_output_length(input_shape[1] + self.length,
self.filter_length,
self.border_mode,
self.subsample[0],
dilation=self.atrous_rate)
return (input_shape[0], length, self.nb_filter)
def call(self, x, mask=None):
return super().call(K.asymmetric_temporal_padding(x, self.length, 0), mask)
| Python | 0 |
56de128ac7462a297505ec4b207d07c1af613c9b | connect annotations to api | ui/app/api/__init__.py | ui/app/api/__init__.py | from flask import Blueprint
api = Blueprint('api', __name__)
#
# end-points to create
# query
from . import query
# services
from . import services
# spans
from . import spans
# annotations
from . import annotations
#
# traces
# services
# annotations
# dependencies
# pin
from . import pin
| from flask import Blueprint
api = Blueprint('api', __name__)
#
# end-points to create
# query
from . import query
# services
from . import services
# spans
from . import spans
#
# traces
# services
# annotations
# dependencies
# pin
from . import pin
| Python | 0.000001 |
c5b00edd9b8acbe594e43ecce093cd1c695b8b01 | Use user ID instead of username to get messages even with username changes | getalltextfromuser.py | getalltextfromuser.py | #!/usr/bin/env python3
"""
A program to extract all text sent by a particular user from a Telegram chat log which is in json form
"""
import argparse
from json import loads
def main():
parser = argparse.ArgumentParser(
description="Extract raw text sent by a user from a json telegram chat log")
parser.add_argument(
'filepath', help='the json file to analyse')
parser.add_argument(
'username', help='the username of the person whose text you want')
args=parser.parse_args()
filepath = args.filepath
username = args.username
user_id = ""
#first, get the ID of the user with that username.
with open(filepath, 'r') as jsonfile:
events = (loads(line) for line in jsonfile)
for event in events:
#check the event is the sort we're looking for
if "from" in event and "text" in event:
if "username" in event["from"]:
#do i need "from" here?
if event["from"]["username"] == username:
#print(event["text"])
print(event['from']['id'])
user_id = event['from']['id']
break
if user_id == "":
print("user not found")
exit()
with open(filepath, 'r') as jsonfile:
events = (loads(line) for line in jsonfile)
for event in events:
#check the event is the sort we're looking for
if "from" in event and "text" in event:
if user_id == event["from"]["id"]:
print(event["text"])
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
"""
A program to extract all text sent by a particular user from a Telegram chat log which is in json form
"""
import argparse
from json import loads
def main():
parser = argparse.ArgumentParser(
description="Extract raw text sent by a user from a json telegram chat log")
parser.add_argument(
'filepath', help='the json file to analyse')
parser.add_argument(
'username', help='the username of the person whose text you want')
args=parser.parse_args()
filepath = args.filepath
username = args.username
with open(filepath, 'r') as jsonfile:
events = (loads(line) for line in jsonfile)
for event in events:
#check the event is the sort we're looking for
if "from" in event and "text" in event:
if "username" in event["from"]:
#do i need "from" here?
if event["from"]["username"] == username:
print(event["text"])
if __name__ == "__main__":
main()
| Python | 0 |
48b227f0019fb28a5b96874f62662fee79998fe5 | Add a TODO for diamondash metric snapshot request auth in diamondash proxy view | go/dashboard/views.py | go/dashboard/views.py | from django.http import HttpResponse
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
from go.dashboard import client
@login_required
@csrf_exempt
@require_http_methods(['GET'])
def diamondash_api_proxy(request):
"""
Proxies client snapshot requests to diamondash.
NOTE: This proxy is a fallback for dev purposes only. A more sensible
proxying solution should be used in production (eg. haproxy).
"""
api = client.get_diamondash_api()
_, url = request.path.split('/diamondash/api', 1)
response = api.raw_request(request.method, url, content=request.body)
# TODO for the case of snapshot requests, ensure the widgets requested are
# allowed for the given account
return HttpResponse(
response['content'],
status=response['code'],
content_type='application/json')
| from django.http import HttpResponse
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
from go.dashboard import client
@login_required
@csrf_exempt
@require_http_methods(['GET'])
def diamondash_api_proxy(request):
"""
Proxies client snapshot requests to diamondash.
NOTE: This proxy is a fallback for dev purposes only. A more sensible
proxying solution should be used in production (eg. haproxy).
"""
api = client.get_diamondash_api()
_, url = request.path.split('/diamondash/api', 1)
response = api.raw_request(request.method, url, content=request.body)
return HttpResponse(
response['content'],
status=response['code'],
content_type='application/json')
| Python | 0 |
e7d6f5fbd21819ba0c5d3b5e952331b2eabe32e8 | move ballsearch para to config | gpbo/core/__init__.py | gpbo/core/__init__.py | from collections import defaultdict
debugoutput=defaultdict(lambda :False)
debugoutput['path']='dbout'
from .optimize import *
from .optutils import *
from .acquisitions import *
from .reccomenders import *
from .config import *
from .GPdc import *
from .ESutils import *
from .choosers import *
| from collections import defaultdict
debugoutput=defaultdict(lambda :False)
debugoutput['path']='dbout'
from .optimize import *
from .optutils import *
from .acquisitions import *
from .reccomenders import *
from .config import *
from .GPdc import *
from .ESutils import *
from .choosers import *
| Python | 0 |
c937d19b263070f380fcbc75dfe60d15840fe477 | Drop call to 'service' wrapper in 'vyos-config-mdns-repeater.py' | src/conf-mode/vyos-config-mdns-repeater.py | src/conf-mode/vyos-config-mdns-repeater.py | #!/usr/bin/env python3
#
# Copyright (C) 2017 VyOS maintainers and contributors
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or later as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#
import sys
import os
import netifaces
import time
import subprocess
from vyos.config import Config
from vyos.util import ConfigError
config_file = r'/etc/default/mdns-repeater'
def get_config():
interface_list = []
conf = Config()
conf.set_level('service mdns repeater')
if not conf.exists(''):
return interface_list
if conf.exists('interfaces'):
intfs_names = conf.return_values('interfaces')
intfs_names=intfs_names.replace("'", "")
intfs_names=intfs_names.split()
for name in intfs_names:
interface_list.append(name)
return interface_list
def verify(mdns):
# '0' interfaces are possible, think of service deletion. Only '1' is not supported!
if len(mdns) == 1:
raise ConfigError('At least 2 interfaces must be specified but %d given!' % len(mdns))
# For mdns-repeater to work it is essential that the interfaces
# have an IP address assigned
for intf in mdns:
try:
netifaces.ifaddresses(intf)[netifaces.AF_INET]
except KeyError as e:
raise ConfigError('No IP address configured for interface "%s"!' % intf)
return None
def generate(mdns):
config_header = '### Autogenerated by vyos-update-mdns-repeater.py on {tm} ###\n'.format(tm=time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()))
if len(mdns) > 0:
config_args = 'DAEMON_ARGS="' + ' '.join(str(e) for e in mdns) + '"\n'
else:
config_args = 'DAEMON_ARGS=""\n'
# write new configuration file
f = open(config_file, 'w')
f.write(config_header)
f.write(config_args)
f.close()
return None
def apply(mdns):
systemd_cmd = ["sudo", "systemctl"]
if len(mdns) == 0:
systemd_cmd.append("stop")
else:
systemd_cmd.append("restart")
systemd_cmd.append("mdns-repeater.service")
subprocess.call(systemd_cmd)
return None
if __name__ == '__main__':
try:
c = get_config()
verify(c)
generate(c)
apply(c)
except ConfigError as e:
print(e)
sys.exit(1)
| #!/usr/bin/env python3
#
# Copyright (C) 2017 VyOS maintainers and contributors
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 or later as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
#
import sys
import os
import netifaces
import time
import subprocess
from vyos.config import Config
from vyos.util import ConfigError
config_file = r'/etc/default/mdns-repeater'
def get_config():
interface_list = []
conf = Config()
conf.set_level('service mdns repeater')
if not conf.exists(''):
return interface_list
if conf.exists('interfaces'):
intfs_names = conf.return_values('interfaces')
intfs_names=intfs_names.replace("'", "")
intfs_names=intfs_names.split()
for name in intfs_names:
interface_list.append(name)
return interface_list
def verify(mdns):
# '0' interfaces are possible, think of service deletion. Only '1' is not supported!
if len(mdns) == 1:
raise ConfigError('At least 2 interfaces must be specified but %d given!' % len(mdns))
# For mdns-repeater to work it is essential that the interfaces
# have an IP address assigned
for intf in mdns:
try:
netifaces.ifaddresses(intf)[netifaces.AF_INET]
except KeyError as e:
raise ConfigError('No IP address configured for interface "%s"!' % intf)
return None
def generate(mdns):
config_header = '### Autogenerated by vyos-update-mdns-repeater.py on {tm} ###\n'.format(tm=time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime()))
if len(mdns) > 0:
config_args = 'DAEMON_ARGS="' + ' '.join(str(e) for e in mdns) + '"\n'
else:
config_args = 'DAEMON_ARGS=""\n'
# write new configuration file
f = open(config_file, 'w')
f.write(config_header)
f.write(config_args)
f.close()
return None
def apply(mdns):
systemd_cmd = ["sudo", "service", "mdns-repeater"]
if len(mdns) == 0:
systemd_cmd.append("stop")
else:
systemd_cmd.append("restart")
subprocess.call(systemd_cmd)
return None
if __name__ == '__main__':
try:
c = get_config()
verify(c)
generate(c)
apply(c)
except ConfigError as e:
print(e)
sys.exit(1)
| Python | 0 |
e964df34a7f1f7dc85da21429b2978b01034140f | Fix typo | i2v/__init__.py | i2v/__init__.py | from i2v.base import Illustration2VecBase
caffe_available = False
chainer_available = False
try:
from i2v.caffe_i2v import CaffeI2V, make_i2v_with_caffe
caffe_available = True
except ImportError:
pass
try:
from i2v.chainer_i2v import ChainerI2V, make_i2v_with_chainer
chainer_available = True
except ImportError:
pass
if not any([caffe_available, chainer_available]):
raise ImportError('i2v requires caffe or chainer package')
| from i2v.base import Illustration2VecBase
caffe_available = False
chainer_available = False
try:
from i2v.caffe_i2v import CaffeI2V, make_i2v_with_caffe
caffe_available = True
except ImportError:
pass
try:
from i2v.chainer_i2v import ChainerI2V, make_i2v_with_chainer
caffe_available = True
except ImportError:
pass
if not any([caffe_available, chainer_available]):
raise ImportError('i2v requires caffe or chainer package')
| Python | 0.999999 |
40c3ed631a962d0a986a7d3752ad1247ded75a33 | Fix save dir of listing files | parsers/transparence-sante/crawl_details.py | parsers/transparence-sante/crawl_details.py | # -*- coding: utf-8 -*-
import os, sys
from crawler import TSCrawler
from parse import parse_listing
from utils import info
from settings import EXTRACT_DETAIL_DIR
import threading
import logging
import time
import Queue
from plan_crawl import get_all_tasks
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-10s) %(message)s',
)
HEADERS = ["rpps", "ville", "adresse", "nom", "prenom", "codepostal", "value", "nature", "intitule", "date", "id", "typologie"]
class ThreadWorker(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
dept_code, pages = self.queue.get()
start = time.time()
worker(dept_code, pages)
self.queue.task_done()
t = time.time() - start
print "Task department=%s, page count=%s finished in: %.1f s, %.1f s/page" % (dept_code, len(pages), t, t / len(pages))
def worker(dept_code, pages):
info("Crawl Dep=%s, page start=%s, page end=%s, page count=%s" % (dept_code, pages[0], pages[-1], len(pages)))
dept_dir = "%s/%s" % (EXTRACT_DETAIL_DIR, dept_code)
if not os.path.isdir(dept_dir):
os.makedirs(dept_dir)
ts_crawler = TSCrawler()
info("Crawl department %s" % dept_code)
form_response = ts_crawler.submit_form_by_dept(dept_code)
for page in pages:
info("Department=%s, page=%s" % (dept_code, page))
listing_filename = "%s/%s/listing-%s-%s.html" % (EXTRACT_DETAIL_DIR, dept_code, dept_code, page)
if os.path.isfile(listing_filename):
continue
if page != 0:
form_response = ts_crawler.get_listing_page(page)
form_html = form_response.read()
data = list(parse_listing(form_html))
# Crawl detail
for idx, _ in enumerate(data):
detail_filename = "%s/%s/avantage-%s-%s-%s.html" % (EXTRACT_DETAIL_DIR, dept_code, dept_code, page, idx)
if os.path.isfile(detail_filename):
continue
with open(detail_filename, "w") as detail_file:
detail_response = ts_crawler.get_detail(idx)
if detail_response:
detail_file.write(detail_response.read())
with open(listing_filename, 'w') as tmp_out:
tmp_out.write(form_html)
info("Departement=%s is finished" % dept_code)
def main():
if len(sys.argv) > 1:
thread_count = int(sys.argv[1])
else:
thread_count = 4
queue = Queue.Queue()
for task in get_all_tasks():
queue.put(task)
for i in range(thread_count):
t = ThreadWorker(queue)
t.setDaemon(True)
t.start()
queue.join()
main() | # -*- coding: utf-8 -*-
import os, sys
from crawler import TSCrawler
from parse import parse_listing
from utils import info
from settings import EXTRACT_DETAIL_DIR
import threading
import logging
import time
import Queue
from plan_crawl import get_all_tasks
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-10s) %(message)s',
)
HEADERS = ["rpps", "ville", "adresse", "nom", "prenom", "codepostal", "value", "nature", "intitule", "date", "id", "typologie"]
class ThreadWorker(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
dept_code, pages = self.queue.get()
start = time.time()
worker(dept_code, pages)
self.queue.task_done()
t = time.time() - start
print "Task department=%s, page count=%s finished in: %.1f s, %.1f s/page" % (dept_code, len(pages), t, t / len(pages))
def worker(dept_code, pages):
info("Crawl Dep=%s, page start=%s, page end=%s, page count=%s" % (dept_code, pages[0], pages[-1], len(pages)))
dept_dir = "%s/%s" % (EXTRACT_DETAIL_DIR, dept_code)
if not os.path.isdir(dept_dir):
os.makedirs(dept_dir)
ts_crawler = TSCrawler()
info("Crawl department %s" % dept_code)
form_response = ts_crawler.submit_form_by_dept(dept_code)
for page in pages:
info("Department=%s, page=%s" % (dept_code, page))
listing_filename = "/%s/listing-%s-%s.html" % (EXTRACT_DETAIL_DIR, dept_code, page)
if os.path.isfile(listing_filename):
continue
if page != 0:
form_response = ts_crawler.get_listing_page(page)
form_html = form_response.read()
data = list(parse_listing(form_html))
# Crawl detail
for idx, _ in enumerate(data):
detail_filename = "%s/%s/avantage-%s-%s-%s.html" % (EXTRACT_DETAIL_DIR, dept_code, dept_code, page, idx)
if os.path.isfile(detail_filename):
continue
with open(detail_filename, "w") as detail_file:
detail_response = ts_crawler.get_detail(idx)
if detail_response:
detail_file.write(detail_response.read())
with open(listing_filename, 'w') as tmp_out:
tmp_out.write(form_html)
info("Departement=%s is finished" % dept_code)
def main():
if len(sys.argv) > 1:
thread_count = int(sys.argv[1])
else:
thread_count = 4
queue = Queue.Queue()
for task in get_all_tasks():
queue.put(task)
for i in range(thread_count):
t = ThreadWorker(queue)
t.setDaemon(True)
t.start()
queue.join()
main() | Python | 0 |
5d32ee0e41aee95f30f972eef3d1abcf9de50a0c | Kill unused var | untz_manager/__main__.py | untz_manager/__main__.py | """Main entry point for untz."""
from concurrent.futures import ThreadPoolExecutor
import logging
import os
from .encoder import apply_gain, encode_file
from .utils import get_args, preflight_checks, recursive_file_search
ARGS = get_args()
LOGGER = logging.getLogger(__name__)
def _encode_on_filter(file_entry):
LOGGER.info('Encoding "%s"', file_entry)
if file_entry.lower().endswith('.flac'):
encode_file(file_entry,
ARGS.base_dir.rstrip('/'),
ARGS.pattern,
ARGS.quality,
ARGS.ogg_cli_parameters)
def main():
"""Main logic for untz."""
if ARGS.verbose:
logging.basicConfig(level=logging.DEBUG)
preflight_checks()
LOGGER.info('Starting %d threads.', ARGS.threads)
with ThreadPoolExecutor(max_workers=ARGS.threads) as tpe:
for i in ARGS.inputs:
if os.path.isdir(i):
tpe.map(_encode_on_filter, recursive_file_search(i))
else:
tpe.submit(_encode_on_filter, i)
if ARGS.replaygain:
apply_gain(ARGS.base_dir)
LOGGER.warning('Program exiting now.')
| """Main entry point for untz."""
from concurrent.futures import ThreadPoolExecutor
import logging
import os
from .encoder import apply_gain, encode_file
from .utils import get_args, preflight_checks, recursive_file_search
ARGS = get_args()
LOGGER = logging.getLogger(__name__)
threads = [] # pylint: disable=C0103
def _encode_on_filter(file_entry):
LOGGER.info('Encoding "%s"', file_entry)
if file_entry.lower().endswith('.flac'):
encode_file(file_entry,
ARGS.base_dir.rstrip('/'),
ARGS.pattern,
ARGS.quality,
ARGS.ogg_cli_parameters)
def main():
"""Main logic for untz."""
if ARGS.verbose:
logging.basicConfig(level=logging.DEBUG)
preflight_checks()
LOGGER.info('Starting %d threads.', ARGS.threads)
with ThreadPoolExecutor(max_workers=ARGS.threads) as tpe:
for i in ARGS.inputs:
if os.path.isdir(i):
tpe.map(_encode_on_filter, recursive_file_search(i))
else:
tpe.submit(_encode_on_filter, i)
if ARGS.replaygain:
apply_gain(ARGS.base_dir)
LOGGER.warning('Program exiting now.')
| Python | 0 |
ae4da4d5d6af27ddab376cb41067f21b053fcf5e | make tokenz lazy | goethe/corpora.py | goethe/corpora.py | import os
from . import util
import itertools as it
class Corpus:
def __init__(self, path, limit=None):
"""Pass path to corpus. Expects following structure:
path/to/my/corpus
corpus.txt
corpus.tokens.txt
"""
self.path = os.path.normpath(path)
self.limit = limit
def __iter__(self):
"""Return generator yielding tokens.
"""
return self.tokens()
def sents(self):
"""Yield sentences from file.
"""
path = self.file_path(use_tokens=False)
with open(path) as f:
yield from (l.strip() for l in f)
def tokens(self):
"""Yield from file a list of tokens per sentence.
"""
path = self.file_path(use_tokens=True)
with open(path) as f:
tokens = (line.strip().split() for line in f)
yield from limit_iter(tokens) if self.limit else tokens
def limit_iter(self, iterator):
"""Return iterator that yields self.limit elements of the passed
iterator.
"""
return it.islice(iterator, self.limit)
def file_path(self, use_tokens):
"""Return path to either sentence or token file.
Example:
'abc/def/corpus'
--> 'abc/def/corpus/corpus.txt'
--> 'abc/def/corpus/corpus.tokens.txt'
"""
corpus_name = os.path.basename(self.path)
file = ('%s.tokens.txt' if use_tokens else '%s.txt') % corpus_name
return os.path.join(self.path, file)
def random(self, k):
"""Randomly select a list of k token lists.
(Will load k elements into memory!)
"""
return util.rsample(self.tokens(), k)
| import os
from . import util
import itertools as it
class Corpus:
def __init__(self, path, limit=None):
"""Pass path to corpus. Expects following structure:
path/to/my/corpus
corpus.txt
corpus.tokens.txt
"""
self.path = os.path.normpath(path)
self.limit = limit
def __iter__(self):
"""Return generator yielding tokens.
"""
return self.tokens()
def sents(self):
"""Yield sentences from file.
"""
path = self.file_path(use_tokens=False)
with open(path) as f:
yield from (l.strip() for l in f)
def tokens(self):
"""Yield from file a list of tokens per sentence.
"""
path = self.file_path(use_tokens=True)
with open(path) as f:
tokens = [line.strip().split() for line in f]
yield from limit_iter(tokens) if self.limit else tokens
def limit_iter(self, iterator):
"""Return iterator that yields self.limit elements of the passed
iterator.
"""
return it.islice(iterator, self.limit)
def file_path(self, use_tokens):
"""Return path to either sentence or token file.
Example:
'abc/def/corpus'
--> 'abc/def/corpus/corpus.txt'
--> 'abc/def/corpus/corpus.tokens.txt'
"""
corpus_name = os.path.basename(self.path)
file = ('%s.tokens.txt' if use_tokens else '%s.txt') % corpus_name
return os.path.join(self.path, file)
def random(self, k):
"""Randomly select a list of k token lists.
(Will load k elements into memory!)
"""
return util.rsample(self.tokens(), k)
| Python | 0.001279 |
c6fe6e7ae212dab3b8cc4615355f782664dc2d05 | raise invalid error in relations if unable to get rid or rtype | drfjsonapi/relations.py | drfjsonapi/relations.py | """
drfjsonapi.relations
~~~~~~~~~~~~~~~~~~~~
DRF relationship fields to assist with a JSON API spec
compliant API.
"""
from django.utils.translation import ugettext_lazy as _
from rest_framework.relations import SlugRelatedField
class JsonApiRelatedField(SlugRelatedField):
""" JSON API related field for relationships """
default_error_messages = {
'does_not_exist': _('Does not exist.'),
'invalid': _('Invalid value.'),
'invalid_rtype': _('Invalid resource type of "{given}".'),
}
def __init__(self, slug_field='id', **kwargs):
""" Process our custom attrs so DRF doesn't barf """
self.rtype = kwargs.pop('rtype', None)
super().__init__(slug_field=slug_field, **kwargs)
def get_rtype(self, instance):
""" Return the "Resource Identifier" type member """
return self.rtype
def to_internal_value(self, data):
""" DRF override during deserialization
A JSON API normalized relationship will have the following
members at a minimum:
{
'id': '123',
'type': 'actors',
}
"""
try:
rid, rtype = data['id'], data['type']
except TypeError:
self.fail('invalid')
# raises exc if not found, instance guaranteed
instance = super().to_internal_value(rid)
_rtype = self.get_rtype(instance)
if _rtype != rtype:
self.fail('invalid_rtype', given=rtype)
return instance
def to_representation(self, obj):
""" DRF override during serialization
`to_representation` could return None if the relationship
was cleared (OneToOne) & deleted but still present in
memory.
"""
ret = super().to_representation(obj)
if ret is not None:
return {
'id': str(ret),
'type': self.get_rtype(obj),
}
return None
| """
drfjsonapi.relations
~~~~~~~~~~~~~~~~~~~~
DRF relationship fields to assist with a JSON API spec
compliant API.
"""
from django.utils.translation import ugettext_lazy as _
from rest_framework.relations import SlugRelatedField
class JsonApiRelatedField(SlugRelatedField):
""" JSON API related field for relationships """
default_error_messages = {
'does_not_exist': _('Does not exist.'),
'invalid': _('Invalid value.'),
'invalid_rtype': _('Invalid resource type of "{given}".'),
}
def __init__(self, slug_field='id', **kwargs):
""" Process our custom attrs so DRF doesn't barf """
self.rtype = kwargs.pop('rtype', None)
super().__init__(slug_field=slug_field, **kwargs)
def get_rtype(self, instance):
""" Return the "Resource Identifier" type member """
return self.rtype
def to_internal_value(self, data):
""" DRF override during deserialization
A JSON API normalized relationship will have the following
members at a minimum:
{
'id': '123',
'type': 'actors',
}
"""
rid, rtype = data['id'], data['type']
# raises exc if not found, instance guaranteed
instance = super().to_internal_value(rid)
_rtype = self.get_rtype(instance)
if _rtype != rtype:
self.fail('invalid_rtype', given=rtype)
return instance
def to_representation(self, obj):
""" DRF override during serialization
`to_representation` could return None if the relationship
was cleared (OneToOne) & deleted but still present in
memory.
"""
ret = super().to_representation(obj)
if ret is not None:
return {
'id': str(ret),
'type': self.get_rtype(obj),
}
| Python | 0 |
6b8b2ebfd17cd96a08511a31d2f1159981b5c7cd | Update drakar.py | apps/drakar.py | apps/drakar.py | import os
import sys
import platform
from os.path import isfile, isdir, join
DRAKAR_PATH = os.environ.get('DRAKAR', '/mnt/drakar')
if not isdir(DRAKAR_PATH):
raise OSError("No such directory: '{}'".format(DRAKAR_PATH))
SYSTEM = sys.platform + '-' + platform.machine()
sources = {
'linux2-x86_64/processing-2.1-linux64.tgz': 'http://download.processing.org/processing-2.1-linux64.tgz',
}
def get_archive(filename):
archives_path = join(DRAKAR_PATH, 'archives', SYSTEM)
# => /mnt/drakar/archives/linux2-x86_64
file_path = join(archives_path, filename)
# => /mnt/drakar/archives/linux2-x86_64/filename.foo
if not isfile(file_path):
here = os.getcwd()
source = sources[join(SYSTEM, filename)]
os.makedirs(archives_path)
os.chdir(archives_path)
os.system('wget ' + source)
os.chdir(here)
if isfile(file_path):
return file_path
else:
raise IOError("Could not obtain '{}' in Drakar".format(filename))
print(get_archive('processing-2.1-linux64.tgz'))
| import os
import sys
import platform
from os.path import isfile, isdir, join
DRAKAR_PATH = os.environ.get('DRAKAR', '/mnt/drakar')
if not isdir(DRAKAR_PATH):
raise OSError("No such directory: '{}'".format(DRAKAR_PATH))
SYSTEM = sys.platform + '-' + platform.machine()
sources = {
'linux2-x86_64/processing-2.1-linux64.tgz': 'http://download.processing.org/processing-2.1-linux64.tgz',
}
def get_archive(filename):
archives_path = join(DRAKAR_PATH, 'archives', SYSTEM)
# => /mnt/drakar/archives/linux2-x86_64
file_path = join(archives_path, filename)
# => /mnt/drakar/archives/linux2-x86_64/filename.foo
if not isfile(file_path):
here = os.getcwd()
source = sources[join(SYSTEM, filename)]
os.makedirs(archives_path)
os.chdir(archives_path)
os.system('wget ' + source)
os.chdir(here)
if isfile(file_path):
return file_path
else:
raise IOError("Could not obtain '{}' in Drakar".format(filename))
get_archive('processing-2.1-linux64.tgz')
| Python | 0 |
c2e36c0c59e728e246f20aacbc5f6f368ca274b7 | add comment | usr/sbin/traverse_dir.py | usr/sbin/traverse_dir.py | #!/usr/bin/env python
###############################################################################
# Copyright (c) 2015 Jamis Hoo
# Project:
# Filename: traverse_dir.py
# Version: 1.0
# Author: Jamis Hoo
# E-mail: hoojamis@gmail.com
# Date: Aug 3, 2015
# Time: 14:06:02
# Description:
###############################################################################
from __future__ import print_function
import sys
import os
import re
import config_load
# command line arguments: lib_path conf_path
if __name__ == "__main__":
if len(sys.argv) < 3:
print("Error: Command line arguments error. Please view source code to get help. ")
exit(1)
lib_path = str(sys.argv[1])
conf_path = str(sys.argv[2])
if not os.path.isabs(conf_path):
print("Error: Configuration path", conf_path, "is not absolute path. ")
exit(1)
if not os.path.isabs(lib_path):
print("Error: Library pth", lib_path, "is not absolute path. ")
exit(1)
# non-builtin modules mustn't be loaded before this statement
sys.path.insert(0, lib_path)
from job_queue import JobQueue
# load config
config = config_load.load_config(conf_path)
print(config)
# check config
mandatory_options = [
("MigrateInfo", "migrate.type"),
("Local", "local.image_root_path"),
("AppInfo", "appinfo.appid"),
("AppInfo", "appinfo.secretid"),
("AppInfo", "appinfo.secretkey"),
("AppInfo", "appinfo.bucket"),
("ToolConfig", "concurrency")
]
for section, option in mandatory_options:
if section not in config or option not in config[section]:
print("Error: Option", section + "." + option, "is required. ")
exit(1)
if not os.path.isabs(config["Local"]["local.image_root_path"]):
print("Error: Image root path", config["Local"]["local.image_root_path"], "is not absolute path")
exit(1)
# only filenames matching this regex will be uploaded, others would be ignored
filename_pattern = re.compile(".*\.(?:jpg|jpeg|png|gif|bmp|webp)$", re.IGNORECASE)
# use this to match all filenames
# filename_pattern = None
image_root_path = os.path.abspath(os.path.expanduser(config["Local"]["local.image_root_path"]))
job_queue = JobQueue(
int(config["ToolConfig"]["concurrency"]),
config["AppInfo"]["appinfo.appid"],
config["AppInfo"]["appinfo.bucket"],
config["AppInfo"]["appinfo.secretid"],
config["AppInfo"]["appinfo.secretkey"]
)
# traverse dir
for dirpath, dirs, files in os.walk(image_root_path):
for filename in files:
if filename_pattern and not filename_pattern.match(filename):
continue
full_name = os.path.join(dirpath, filename)
fileid = full_name[len(image_root_path) + 1:]
#print(full_name, ":", fileid)
job_queue.inqueue(0, full_name, fileid)
job_queue.finish()
| #!/usr/bin/env python
###############################################################################
# Copyright (c) 2015 Jamis Hoo
# Project:
# Filename: traverse_dir.py
# Version: 1.0
# Author: Jamis Hoo
# E-mail: hoojamis@gmail.com
# Date: Aug 3, 2015
# Time: 14:06:02
# Description:
###############################################################################
from __future__ import print_function
import sys
import os
import re
import config_load
if __name__ == "__main__":
if len(sys.argv) < 3:
print("Error: Command line arguments error. Please view source code to get help. ")
exit(1)
lib_path = str(sys.argv[1])
conf_path = str(sys.argv[2])
if not os.path.isabs(conf_path):
print("Error: Configuration path", conf_path, "is not absolute path. ")
exit(1)
if not os.path.isabs(lib_path):
print("Error: Library pth", lib_path, "is not absolute path. ")
exit(1)
# non-builtin modules mustn't be loaded before this statement
sys.path.insert(0, lib_path)
from job_queue import JobQueue
# load config
config = config_load.load_config(conf_path)
print(config)
# check config
mandatory_options = [
("MigrateInfo", "migrate.type"),
("Local", "local.image_root_path"),
("AppInfo", "appinfo.appid"),
("AppInfo", "appinfo.secretid"),
("AppInfo", "appinfo.secretkey"),
("AppInfo", "appinfo.bucket"),
("ToolConfig", "concurrency")
]
for section, option in mandatory_options:
if section not in config or option not in config[section]:
print("Error: Option", section + "." + option, "is required. ")
exit(1)
if not os.path.isabs(config["Local"]["local.image_root_path"]):
print("Error: Image root path", config["Local"]["local.image_root_path"], "is not absolute path")
exit(1)
# only filenames matching this regex will be uploaded, others would be ignored
filename_pattern = re.compile(".*\.(?:jpg|jpeg|png|gif|bmp|webp)$", re.IGNORECASE)
# use this to match all filenames
# filename_pattern = None
image_root_path = os.path.abspath(os.path.expanduser(config["Local"]["local.image_root_path"]))
job_queue = JobQueue(
int(config["ToolConfig"]["concurrency"]),
config["AppInfo"]["appinfo.appid"],
config["AppInfo"]["appinfo.bucket"],
config["AppInfo"]["appinfo.secretid"],
config["AppInfo"]["appinfo.secretkey"]
)
# traverse dir
for dirpath, dirs, files in os.walk(image_root_path):
for filename in files:
if filename_pattern and not filename_pattern.match(filename):
continue
full_name = os.path.join(dirpath, filename)
fileid = full_name[len(image_root_path) + 1:]
#print(full_name, ":", fileid)
job_queue.inqueue(0, full_name, fileid)
job_queue.finish()
| Python | 0 |
1c02294073c855fab8d6fc0965f3584b0ac0137b | clean up example file | examples/example.py | examples/example.py | #!/usr/bin/env python3
import matplotlib.pyplot as plt
from oemof import db
from dingo.core import NetworkDingo
from dingo.tools import config as cfg_dingo
plt.close('all')
cfg_dingo.load_config('config_db_tables')
cfg_dingo.load_config('config_calc')
cfg_dingo.load_config('config_files')
cfg_dingo.load_config('config_misc')
# database connection
conn = db.connection(section='oedb')
# instantiate dingo network object
nd = NetworkDingo(name='network')
# mv_grid_districts = [386,372,406,371,402,415,480,424,489,367,359,569,591]
mv_grid_districts=[480]
nd.import_mv_grid_districts(conn, mv_grid_districts)
nd.import_generators(conn)
nd.mv_parametrize_grid()
nd.mv_routing(debug=False, animation=False)
nd.connect_generators()
nd.set_branch_ids()
# DEBUG (Compare graphs to CLEAN UP THE SALT)
#conn.close()
#from dingo.tools.debug import compare_graphs
#compare_graphs(graph=nd._mv_grid_districts[0].mv_grid._graph,
# mode='compare')
nd.set_circuit_breakers()
# Open and close all circuit breakers in grid
[gd.mv_grid.open_circuit_breakers() for gd in nd._mv_grid_districts]
# Analyze grid by power flow analysis
for mv_grid_district in nd._mv_grid_districts:
mv_grid_district.mv_grid.run_powerflow(conn, method='onthefly')
nd.export_mv_grid(conn, mv_grid_districts)
conn.close()
# reinforce MV grid
#nd.reinforce_grid()
| #!/usr/bin/env python3
import matplotlib.pyplot as plt
from oemof import db
conn = db.connection(section='oedb')
from dingo.core import NetworkDingo
from dingo.tools import config as cfg_dingo
from dingo.tools.debug import compare_graphs
plt.close('all')
cfg_dingo.load_config('config_db_tables')
cfg_dingo.load_config('config_calc')
cfg_dingo.load_config('config_files')
cfg_dingo.load_config('config_misc')
# get engine for database connection
#conn = db.connection(db_section='ontohub_wdb', cfg_file='~/.dingo/config') # <-- TODO: include custom config file from given path (+input for oemof)
# instantiate dingo network object
nd = NetworkDingo(name='network')
# mv_grid_districts=[360, 571, 593, 368, 491, 425, 416, 372, 387, 407, 403, 373, 482] # some MV grid_districts from SPF region
# mv_grid_districts=[360, 571, 593, 368, 491, 416, 372, 387, 407, 403, 373, 482] # some MV grid_districts from SPF region
# mv_grid_districts=[482]
# mv_grid_districts = [386,372,406,371,402,415,480,424,489,367,359,569,591]
mv_grid_districts=[480]
nd.import_mv_grid_districts(conn, mv_grid_districts)
nd.import_generators(conn)
nd.mv_parametrize_grid()
nd.mv_routing(debug=False, animation=False)
nd.connect_generators()
nd.set_branch_ids()
#conn.close()
# DEBUG (CLEAN UP THE SALT)
#compare_graphs(graph=nd._mv_grid_districts[0].mv_grid._graph,
# mode='compare')
nd.set_circuit_breakers()
# Open and close all circuit breakers in grid (for testing)
[gd.mv_grid.open_circuit_breakers() for gd in nd._mv_grid_districts]
#nd._mv_grid_districts[0].mv_grid.close_circuit_breakers()
# Analyze grid by power flow analysis
for mv_grid_district in nd._mv_grid_districts:
mv_grid_district.mv_grid.run_powerflow(conn, method='onthefly')
nd.export_mv_grid(conn, mv_grid_districts)
conn.close()
#nd.reinforce_grid()
# for edge in nd._mv_grid_districts[0].mv_grid.graph_edges():
# if edge['branch'].type is not None:
# print(edge['branch'].type['name'])
# else:
# print('None')
# lvrg = []
# for mv_grid_district in nd.mv_grid_districts():
# #print(mv_grid_district._lv_load_area_groups)
# #print(type(mv_grid_district._lv_load_area_groups))
# for lv_load_area_group in iter(mv_grid_district._lv_load_area_groups):
# lvrg.append([str(lv_load_area_group), lv_load_area_group.peak_load_sum, lv_load_area_group.branch_length_sum])
# lvrg = sorted(lvrg, key=lambda x: x[1])
#
# for lvrg_name, lvrg_load, lvrg_length in lvrg:
# print(lvrg_name, lvrg_load, lvrg_length)
#df = nx.to_pandas_dataframe(nd._mv_grid_districts[0].mv_grid._graph)
# import pprint
# for edge in nd._mv_grid_districts[0].mv_grid._graph.edge.keys():
# # print(edge, type(edge))
# pprint.pprint(edge)
# pprint.pprint(nd._mv_grid_districts[0].mv_grid._graph.edge[edge])
#nd._mv_grid_districts[0].mv_grid.graph_draw()
| Python | 0.000002 |
2645ac98fd2698bcfbf4a23cdb6c9583e6b31a50 | create test user from python updated | src/apps/flow_manager/createdb.py | src/apps/flow_manager/createdb.py | import requests
import json
dbhost = "localhost"
dbport = "5984"
dbuser = "root"
dbpass = "asm123"
database = "faucet"
userdatabase = "users"
username = "testflowmgr@faucetsdn.org"
password = "testflowmgr"
role = "1"
data = {"username": username, "password": password, "role": role}
createdb = requests.put("http://"+dbuser+":"+dbpass+"@"+dbhost+":"+dbport+"/"+userdatabase+"/")
print createdb
view_data = {'_id': '_design/users','views': {'users': {'map': 'function(doc){ emit(doc._id, doc)}'}}}
view_data = json.dumps(view_data)
createvw = requests.put(url="http://" + dbuser + ":" + dbpass + "@" + dbhost + ":" + dbport + "/" + userdatabase + "/_design/users/",
data=view_data)
print createvw
createuser =requests.post(url="http://"+dbhost+":"+dbport+"/"+userdatabase+"/", json={"username": username, "password": password, "role": role})
print createuser
| import requests
dbhost = "localhost"
dbport = "5984"
dbuser = "root"
dbpass = "asm123"
database = "faucet"
userdatabase = "users"
username = "testflowmgr@faucetsdn.org"
password = "testflowmgr"
role = "1"
data = {"username": username, "password": password, "role": role}
# createdb = requests.put("http://"+dbuser+":"+dbpass+"@"+dbhost+":"+dbport+"/"+userdatabase+"/")
# print createdb
view_data = "{_id: '_design/users',views: {'users': {'map': 'function(doc){ emit(doc._id, doc)}'}}}"
createvw = requests.put(
url="http://" + dbuser + ":" + dbpass + "@" + dbhost + ":" + dbport + "/" + userdatabase + "/_design/users/",
data=view_data)
requests.put(url="http://" + dbuser + ":" + dbpass + "@" + dbhost + ":" + dbport + "/" + userdatabase + "/_design/users/",
data={'_id': '_design/users','views': {'users': {'map': 'function(doc){ emit(doc._id, doc)}'}}})
print createvw.status_code, createvw.content
# createuser =requests.post(url="http://"+dbhost+":"+dbport+"/"+userdatabase+"/", json={"username": username, "password": password, "role": role})
# print createuser
| Python | 0.000001 |
f6a5ad0d2107b60899f5abaf2dbce65beae34a59 | Drop remaining "OrderedDict" usages. | utilities/export_todo.py | utilities/export_todo.py | #!/usr/bin/env python
"""
Export TODOs
============
"""
from __future__ import annotations
import codecs
import os
__copyright__ = "Copyright 2013 Colour Developers"
__license__ = "New BSD License - https://opensource.org/licenses/BSD-3-Clause"
__maintainer__ = "Colour Developers"
__email__ = "colour-developers@colour-science.org"
__status__ = "Production"
__all__ = [
"TODO_FILE_TEMPLATE",
"extract_todo_items",
"export_todo_items",
]
TODO_FILE_TEMPLATE = """
Colour - TODO
=============
TODO
----
{0}
About
-----
| **Colour** by Colour Developers
| Copyright 2013 Colour Developers – \
`colour-developers@colour-science.org <colour-developers@colour-science.org>`__
| This software is released under terms of New BSD License: \
https://opensource.org/licenses/BSD-3-Clause
| `https://github.com/colour-science/colour \
<https://github.com/colour-science/colour>`__
"""[
1:
]
def extract_todo_items(root_directory: str) -> dict:
"""
Extract the TODO items from given directory.
Parameters
----------
root_directory
Directory to extract the TODO items from.
Returns
-------
:class:`dict`
TODO items.
"""
todo_items = {}
for root, dirnames, filenames in os.walk(root_directory):
for filename in filenames:
if not filename.endswith(".py"):
continue
filename = os.path.join(root, filename)
with codecs.open(filename, encoding="utf8") as file_handle:
content = file_handle.readlines()
in_todo = False
line_number = -1
todo_item = []
for i, line in enumerate(content):
line = line.strip()
if line.startswith("# TODO:"):
in_todo = True
line_number = i
todo_item.append(line)
continue
if in_todo and line.startswith("#"):
todo_item.append(line.replace("#", "").strip())
elif len(todo_item):
key = filename.replace("../", "")
if not todo_items.get(key):
todo_items[key] = []
todo_items[key].append((line_number, " ".join(todo_item)))
in_todo = False
line_number
todo_item = []
return todo_items
def export_todo_items(todo_items: dict, file_path: str):
"""
Export TODO items to given file.
Parameters
----------
todo_items
TODO items.
file_path
File to write the TODO items to.
"""
todo_rst = []
for module, todo_items in todo_items.items():
todo_rst.append(f"- {module}\n")
for line_numer, todo_item in todo_items:
todo_rst.append(f" - Line {line_numer} : {todo_item}")
todo_rst.append("\n")
with codecs.open(file_path, "w", encoding="utf8") as todo_file:
todo_file.write(TODO_FILE_TEMPLATE.format("\n".join(todo_rst[:-1])))
if __name__ == "__main__":
export_todo_items(
extract_todo_items(os.path.join("..", "colour")),
os.path.join("..", "TODO.rst"),
)
| #!/usr/bin/env python
"""
Export TODOs
============
"""
from __future__ import annotations
import codecs
import os
from collections import OrderedDict
__copyright__ = "Copyright 2013 Colour Developers"
__license__ = "New BSD License - https://opensource.org/licenses/BSD-3-Clause"
__maintainer__ = "Colour Developers"
__email__ = "colour-developers@colour-science.org"
__status__ = "Production"
__all__ = [
"TODO_FILE_TEMPLATE",
"extract_todo_items",
"export_todo_items",
]
TODO_FILE_TEMPLATE = """
Colour - TODO
=============
TODO
----
{0}
About
-----
| **Colour** by Colour Developers
| Copyright 2013 Colour Developers – \
`colour-developers@colour-science.org <colour-developers@colour-science.org>`__
| This software is released under terms of New BSD License: \
https://opensource.org/licenses/BSD-3-Clause
| `https://github.com/colour-science/colour \
<https://github.com/colour-science/colour>`__
"""[
1:
]
def extract_todo_items(root_directory: str) -> OrderedDict:
"""
Extract the TODO items from given directory.
Parameters
----------
root_directory
Directory to extract the TODO items from.
Returns
-------
:class:`collections.OrderedDict`
TODO items.
"""
todo_items = OrderedDict()
for root, dirnames, filenames in os.walk(root_directory):
for filename in filenames:
if not filename.endswith(".py"):
continue
filename = os.path.join(root, filename)
with codecs.open(filename, encoding="utf8") as file_handle:
content = file_handle.readlines()
in_todo = False
line_number = -1
todo_item = []
for i, line in enumerate(content):
line = line.strip()
if line.startswith("# TODO:"):
in_todo = True
line_number = i
todo_item.append(line)
continue
if in_todo and line.startswith("#"):
todo_item.append(line.replace("#", "").strip())
elif len(todo_item):
key = filename.replace("../", "")
if not todo_items.get(key):
todo_items[key] = []
todo_items[key].append((line_number, " ".join(todo_item)))
in_todo = False
line_number
todo_item = []
return todo_items
def export_todo_items(todo_items: OrderedDict, file_path: str):
"""
Export TODO items to given file.
Parameters
----------
todo_items
TODO items.
file_path
File to write the TODO items to.
"""
todo_rst = []
for module, todo_items in todo_items.items():
todo_rst.append(f"- {module}\n")
for line_numer, todo_item in todo_items:
todo_rst.append(f" - Line {line_numer} : {todo_item}")
todo_rst.append("\n")
with codecs.open(file_path, "w", encoding="utf8") as todo_file:
todo_file.write(TODO_FILE_TEMPLATE.format("\n".join(todo_rst[:-1])))
if __name__ == "__main__":
export_todo_items(
extract_todo_items(os.path.join("..", "colour")),
os.path.join("..", "TODO.rst"),
)
| Python | 0 |
547ee3fb5db9ebb0bed0443d865ec76f44904b9e | Add url_shortener.views.render_preview function | url_shortener/views.py | url_shortener/views.py | # -*- coding: utf-8 -*-
from flask import session, redirect, url_for, flash, render_template
from . import app
from .forms import ShortenedUrlForm
from .models import ShortenedUrl, register
@app.route('/', methods=['GET', 'POST'])
def shorten_url():
'''Display form and handle request for url shortening
If short url is successfully created or found for the
given url, its alias property is saved in session, and
the function redirects to its route. After redirection,
the alias is used to query for newly created shortened
url, and information about it is presented.
If there are any errors for data entered by the user into
the input tex field, they are displayed.
:returns: a response generated by rendering the template,
either directly or after redirection.
'''
form = ShortenedUrlForm()
if form.validate_on_submit():
shortened_url = ShortenedUrl.get_or_create(form.url.data)
register(shortened_url)
session['new_alias'] = str(shortened_url.alias)
return redirect(url_for(shorten_url.__name__))
else:
for error in form.url.errors:
flash(error, 'error')
try:
new_shortened_url = ShortenedUrl.get_or_404(session['new_alias'])
except KeyError:
new_shortened_url = None
return render_template(
'shorten_url.html',
form=form,
new_shortened_url=new_shortened_url
)
def render_preview(shortened_url, warning_message=None):
return render_template(
'preview.html',
shortened_url=shortened_url,
warning=warning_message
)
@app.route('/<alias>')
def redirect_for(alias):
''' Redirect to address assigned to given alias
:param alias: a string value by which we search for
an associated url. If it is not found, a 404 error
occurs
:returns: a redirect to target url of short url, if
found.
'''
shortened_url = ShortenedUrl.get_or_404(alias)
return redirect(shortened_url.target)
@app.route('/preview/<alias>')
def preview(alias):
''' Show the preview for given alias
The preview contains a short url and a target url
associated with it.
:param alias: a string value by which we search
for an associated url. If it is not found, a 404
error occurs.
:returns: a response generated from the preview template
'''
shortened_url = ShortenedUrl.get_or_404(alias)
return render_template(
'preview.html',
short_url=shortened_url.short_url,
target=shortened_url.target
)
@app.errorhandler(404)
def not_found(error):
return render_template('not_found.html')
@app.errorhandler(500)
def server_error(error):
return render_template('server_error.html')
| # -*- coding: utf-8 -*-
from flask import session, redirect, url_for, flash, render_template
from . import app
from .forms import ShortenedUrlForm
from .models import ShortenedUrl, register
@app.route('/', methods=['GET', 'POST'])
def shorten_url():
'''Display form and handle request for url shortening
If short url is successfully created or found for the
given url, its alias property is saved in session, and
the function redirects to its route. After redirection,
the alias is used to query for newly created shortened
url, and information about it is presented.
If there are any errors for data entered by the user into
the input tex field, they are displayed.
:returns: a response generated by rendering the template,
either directly or after redirection.
'''
form = ShortenedUrlForm()
if form.validate_on_submit():
shortened_url = ShortenedUrl.get_or_create(form.url.data)
register(shortened_url)
session['new_alias'] = str(shortened_url.alias)
return redirect(url_for(shorten_url.__name__))
else:
for error in form.url.errors:
flash(error, 'error')
try:
new_shortened_url = ShortenedUrl.get_or_404(session['new_alias'])
except KeyError:
new_shortened_url = None
return render_template(
'shorten_url.html',
form=form,
new_shortened_url=new_shortened_url
)
@app.route('/<alias>')
def redirect_for(alias):
''' Redirect to address assigned to given alias
:param alias: a string value by which we search for
an associated url. If it is not found, a 404 error
occurs
:returns: a redirect to target url of short url, if
found.
'''
shortened_url = ShortenedUrl.get_or_404(alias)
return redirect(shortened_url.target)
@app.route('/preview/<alias>')
def preview(alias):
''' Show the preview for given alias
The preview contains a short url and a target url
associated with it.
:param alias: a string value by which we search
for an associated url. If it is not found, a 404
error occurs.
:returns: a response generated from the preview template
'''
shortened_url = ShortenedUrl.get_or_404(alias)
return render_template(
'preview.html',
short_url=shortened_url.short_url,
target=shortened_url.target
)
@app.errorhandler(404)
def not_found(error):
return render_template('not_found.html')
@app.errorhandler(500)
def server_error(error):
return render_template('server_error.html')
| Python | 0.000004 |
561e7905de823e5c2ff2f4822d4051d9a7635dfc | Fix checking whether the heap contains the node when e.g. calling .pop(). | idiokit/heap.py | idiokit/heap.py | class HeapError(Exception):
pass
class Heap(object):
def __init__(self, iterable=()):
self._heap = list()
for value in iterable:
self.push(value)
def _get(self, node):
if not self._heap:
raise HeapError("empty heap")
if node is None:
node = self._heap[0]
if len(self._heap) <= node._index or self._heap[node._index] is not node:
raise HeapError("node not in the heap")
return node
def push(self, value):
node = _Node(len(self._heap), value)
self._heap.append(node)
_up(self._heap, node)
return node
def peek(self, node=None):
return self._get(node)._value
def pop(self, node=None):
node = self._get(node)
last = self._heap.pop()
if last is not node:
self._heap[node._index] = last
last._index = node._index
_down(self._heap, last)
return node._value
def __nonzero__(self):
return not not self._heap
class _Node(object):
__slots__ = "_index", "_value"
def __init__(self, index, value):
self._index = index
self._value = value
def _swap(array, left, right):
array[left._index] = right
array[right._index] = left
left._index, right._index = right._index, left._index
return right, left
def _up(array, node):
while node._index > 0:
parent = array[(node._index - 1) // 2]
if parent._value <= node._value:
break
_swap(array, node, parent)
def _down(array, node):
length = len(array)
while True:
smallest = node
left_index = 2 * node._index + 1
if left_index < length:
left = array[left_index]
if left._value < smallest._value:
smallest = left
right_index = left_index + 1
if right_index < length:
right = array[right_index]
if right._value < smallest._value:
smallest = right
if node is smallest:
break
_swap(array, node, smallest)
if __name__ == "__main__":
import unittest
class HeapTests(unittest.TestCase):
def test_pop(self):
h = Heap([0, 1, 2, 3])
assert h.pop() == 0
assert h.pop() == 1
assert h.pop() == 2
assert h.pop() == 3
self.assertRaises(HeapError, h.pop)
unittest.main()
| class HeapError(Exception):
pass
class Heap(object):
def __init__(self, iterable=()):
self._heap = list()
for value in iterable:
self.push(value)
def _get(self, node):
if not self._heap:
raise HeapError("empty heap")
if node is None:
node = self._heap[0]
if self._heap[node._index] is not node:
raise HeapError("node not in the heap")
return node
def push(self, value):
node = _Node(len(self._heap), value)
self._heap.append(node)
_up(self._heap, node)
return node
def peek(self, node=None):
return self._get(node)._value
def pop(self, node=None):
node = self._get(node)
last = self._heap.pop()
if last is not node:
self._heap[node._index] = last
last._index = node._index
_down(self._heap, last)
return node._value
def __nonzero__(self):
return not not self._heap
class _Node(object):
__slots__ = "_index", "_value"
def __init__(self, index, value):
self._index = index
self._value = value
def _swap(array, left, right):
array[left._index] = right
array[right._index] = left
left._index, right._index = right._index, left._index
return right, left
def _up(array, node):
while node._index > 0:
parent = array[(node._index - 1) // 2]
if parent._value <= node._value:
break
_swap(array, node, parent)
def _down(array, node):
length = len(array)
while True:
smallest = node
left_index = 2 * node._index + 1
if left_index < length:
left = array[left_index]
if left._value < smallest._value:
smallest = left
right_index = left_index + 1
if right_index < length:
right = array[right_index]
if right._value < smallest._value:
smallest = right
if node is smallest:
break
_swap(array, node, smallest)
if __name__ == "__main__":
import unittest
class HeapTests(unittest.TestCase):
def test_pop(self):
h = Heap([0, 1, 2, 3])
assert h.pop() == 0
assert h.pop() == 1
assert h.pop() == 2
assert h.pop() == 3
self.assertRaises(HeapError, h.pop)
unittest.main()
| Python | 0 |
78ac11eed6a98d11cfafcef6757fd91b8bdb7b8e | make UI work | PasswordConverter/PasswordConverter.py | PasswordConverter/PasswordConverter.py | import tkinter as tk
import tkinter.font as tkFont
from tkinter import ttk, tix
import hashlib
import base64
class tolist_frozenset(frozenset):
def __init__(self, obj):
frozenset.__init__(obj)
def s2l(self):
return list(self)
def s2t(self):
return tuple(self)
def __sub__(self, other, *args):
return tolist_frozenset(super().difference(other, *args))
STICK_ALL = tolist_frozenset([tix.N, tix.W, tix.S, tix.E])
STICK_HORIZONTAL = tolist_frozenset([tix.W, tix.E])
STICK_VERTICAL = tolist_frozenset([tix.N, tix.S])
STICK_N = tolist_frozenset([tix.N])
STICK_W = tolist_frozenset([tix.W])
STICK_S = tolist_frozenset([tix.S])
STICK_E = tolist_frozenset([tix.E])
class PasswordConverter(ttk.Frame):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.columnconfigure(0, weight=1)
self.rowconfigure(1, weight=1)
self.pack(fill=tix.BOTH, expand=True)
self.__createWidgets()
def __createWidgets(self):
self.pane = ttk.PanedWindow(self, orient=tix.HORIZONTAL)
self.pane.rowconfigure(0, weight=1)
self.pane.rowconfigure(1, weight=1)
self.pane.columnconfigure(1, weight=1)
self.pane.grid(column=0, row=0, sticky=STICK_HORIZONTAL.s2t())
self.pane.key_label = ttk.Label(self.pane)
self.pane.key_label["text"] = "Key:"
self.pane.key_label.grid(column=0, row=0, sticky=STICK_W.s2t())
self.key_value = tk.StringVar()
self.pane.key = ttk.Entry(self.pane, textvariable=self.key_value)
self.pane.key.grid(column=1, row=0, sticky=STICK_ALL.s2t(), padx=(5, 2), pady=(1, 2))
self.pane.salt_label = ttk.Label(self.pane)
self.pane.salt_label["text"] = "Salt:"
self.pane.salt_label.grid(column=0, row=1, sticky=STICK_W.s2t())
self.salt_value = tk.StringVar()
self.pane.salt = ttk.Entry(self.pane, textvariable=self.salt_value)
self.pane.salt.grid(column=1, row=1, sticky=STICK_ALL.s2t(), padx=(5, 2), pady=(2, 1))
self.pane.button = ttk.Button(self.pane)
self.pane.button["text"] = "计算！"
self.pane.button["command"] = self.__generate_password
self.pane.button.grid(column=2, rowspan=2, row=0, sticky=STICK_VERTICAL.s2t(), padx=(2, 0))
self.text_val = tk.StringVar()
self.text = tix.Text(self, autosep=1)
self.text.grid(column=0, row=1, sticky=STICK_ALL.s2t(), padx=5)
self.quit_btn = ttk.Button(self, text="退出！", style="red.TButton", command=self.master.destroy)
self.quit_btn.grid(column=0, row=2, sticky=STICK_ALL.s2t(), ipady=5)
def __generate_password(self):
pass
if __name__ == "__main__":
root = tix.Tk()
root.title("纸睡的密码生成器")
root.minsize(600, 400)
tkFont.nametofont("TkDefaultFont").config(family="Dengxian", size=11)
style = ttk.Style()
style.configure("basic.TFrame", foreground="black")
style.configure("red.TButton", foreground="red")
mainframe = PasswordConverter(master=root, style="basic.TFrame")
for child in mainframe.winfo_children():
child.grid_configure(padx=5, pady=5)
root.bind('<Escape>', lambda _: root.destroy())
root.mainloop() | import tkinter as tk
import tkinter.font as tkFont
from tkinter import ttk, tix
import hashlib, base64
STICKY_ALL = (tix.N, tix.W, tix.S, tix.E)
STICKY_HORIZONTAL = (tix.W, tix.E)
STICKY_VERTICAL = (tix.N, tix.S)
class PasswordConverter(ttk.Frame):
def __init__(self, **kwargs):
return super().__init__(**kwargs)
self.rowconfigure(1, weight=1)
self.columnconfigure(0, weight=1)
self.pack(fill="both", expand=True)
self.__createWidgets()
def __createWidgets(self):
self.pane = ttk.PanedWindow(self, orient=tix.HORIZONTAL)
self.pane.rowconfigure(0, weight=1)
self.pane.columnconfigure(0, weight=1)
self.pane.grid(row=0, column=0, sticky=STICKY_HORIZONTAL)
# input box
self.pane.entry_value = tk.StringVar()
self.pane.entry = ttk.Entry(self.pane, textvariable=self.pane.entry_value)
self.pane.entry.grid(row=0, column=0, sticky=STICKY_ALL, padx=5)
# generate button
self.pane.generate_button = ttk.Button(self.pane)
self.pane.generate_button["text"] = "生成口令！"
self.pane.generate_button["command"] = self.__generate_password
self.pane.grid(row=0, column=1, sticky=STICKY_ALL, padx=5)
# output_box
def __generate_password(self):
pass | Python | 0.00001 |
b95fa25a5d3a00d8d1113f2d61defee69215374b | add tests for submitted graderoster | course_grader/test/dao/test_graderoster.py | course_grader/test/dao/test_graderoster.py | from django.test import TestCase
from django.utils import timezone
from uw_pws.util import fdao_pws_override
from uw_sws.util import fdao_sws_override
from course_grader.dao.person import PWS
from course_grader.dao.section import get_section_by_label
from course_grader.dao.graderoster import graderoster_for_section
from course_grader.models import SubmittedGradeRoster
from course_grader.exceptions import (
GradingNotPermitted, ReceiptNotFound, GradingPeriodNotOpen)
@fdao_sws_override
@fdao_pws_override
class GraderosterDAOFunctionsTest(TestCase):
def test_graderoster_for_section(self):
section = get_section_by_label('2013,spring,TRAIN,101/A')
user = PWS().get_person_by_regid('FBB38FE46A7C11D5A4AE0004AC494FFE')
gr = graderoster_for_section(section, user, user)
self.assertEqual(len(gr.items), 1000)
def test_submitted_graderoster_for_section(self):
section = get_section_by_label('2013,spring,TRAIN,101/B')
user = PWS().get_person_by_regid('FBB38FE46A7C11D5A4AE0004AC494FFE')
gr = graderoster_for_section(section, user, user)
self.assertEqual(len(gr.items), 1)
self.assertFalse(hasattr(gr, 'submission_id'))
model = SubmittedGradeRoster(
section_id='2013,spring,TRAIN,101/B',
instructor_id='FBB38FE46A7C11D5A4AE0004AC494FFE',
term_id='2013,spring',
submitted_date=timezone.now(),
submitted_by='FBB38FE46A7C11D5A4AE0004AC494FFE',
accepted_date=timezone.now(),
status_code=200,
document=gr.xhtml()
)
model.save()
gr = graderoster_for_section(section, user, user)
self.assertEqual(len(gr.items), 1)
self.assertFalse(hasattr(gr, 'submission_id'))
def test_submitted_only_graderoster_for_section(self):
section = get_section_by_label('2013,spring,TRAIN,101/B')
user = PWS().get_person_by_regid('FBB38FE46A7C11D5A4AE0004AC494FFE')
self.assertRaises(
ReceiptNotFound, graderoster_for_section, section, user, user,
submitted_graderosters_only=True)
gr = graderoster_for_section(section, user, user)
model = SubmittedGradeRoster(
section_id='2013,spring,TRAIN,101/B',
instructor_id='FBB38FE46A7C11D5A4AE0004AC494FFE',
term_id='2013,spring',
submitted_date=timezone.now(),
submitted_by='FBB38FE46A7C11D5A4AE0004AC494FFE',
accepted_date=timezone.now(),
status_code=200,
document=gr.xhtml()
)
model.save()
gr = graderoster_for_section(
section, user, user, submitted_graderosters_only=True)
self.assertEqual(len(gr.items), 1)
self.assertEqual(gr.submission_id, 'B')
def test_graderoster_not_permitted(self):
section = get_section_by_label('2013,spring,TRAIN,100/AA')
user = PWS().get_person_by_regid('9136CCB8F66711D5BE060004AC494FFE')
self.assertRaises(
GradingNotPermitted, graderoster_for_section, section, user, user)
| from django.test import TestCase
from uw_pws.util import fdao_pws_override
from uw_sws.util import fdao_sws_override
from course_grader.dao.person import PWS
from course_grader.dao.section import get_section_by_label
from course_grader.dao.graderoster import graderoster_for_section
from course_grader.exceptions import (
GradingNotPermitted, ReceiptNotFound, GradingPeriodNotOpen)
@fdao_sws_override
@fdao_pws_override
class GraderosterDAOFunctionsTest(TestCase):
def test_graderoster_for_section(self):
section = get_section_by_label('2013,spring,TRAIN,101/A')
user = PWS().get_person_by_regid('FBB38FE46A7C11D5A4AE0004AC494FFE')
gr = graderoster_for_section(section, user, user)
self.assertEqual(len(gr.items), 1000)
def test_submitted_graderoster_for_section(self):
section = get_section_by_label('2013,spring,TRAIN,101/B')
user = PWS().get_person_by_regid('FBB38FE46A7C11D5A4AE0004AC494FFE')
self.assertRaises(
ReceiptNotFound, graderoster_for_section, section, user, user,
submitted_graderosters_only=True)
def test_graderoster_not_permitted(self):
section = get_section_by_label('2013,spring,TRAIN,100/AA')
user = PWS().get_person_by_regid('9136CCB8F66711D5BE060004AC494FFE')
self.assertRaises(
GradingNotPermitted, graderoster_for_section, section, user, user)
| Python | 0 |
69df5ba1baf92238e98065d60dac73d2214787d3 | Fix usage of biobank_identifier parameter | import-imput.py | import-imput.py | from pymongo import MongoClient
import csv
import re
import argparse
def categorize_float(value):
if value <= 0.001:
return "[0,0.001]"
elif value <= 0.01:
return "(0.001,0.01]"
elif value <= 0.1:
return "(0.01,0.1]"
elif value <= 0.2:
return "(0.1,0.2]"
elif value <= 0.3:
return "(0.2,0.3]"
elif value <= 0.4:
return "(0.3,0.4]"
elif value <= 0.5:
return "(0.4,0.5]"
else:
raise ValueError
parser = argparse.ArgumentParser()
parser.add_argument("filename", help="Filename to tsv file")
parser.add_argument("biobank_identifier", help="Identifier to distinguish data in database")
args = parser.parse_args()
mongo_client = MongoClient()
db = mongo_client.gwasc
all_positions = db.gwas.find()
positions = {}
for position in all_positions:
positions["chr"+str(position["CHR_ID"])+":"+str(position["CHR_POS"])] = position
print(len(positions))
counter = 0
with open(args.filename) as tsvfile:
data = csv.reader(tsvfile, delimiter=' ')
for line in data:
chr_id = re.sub("^chr", "", line[0])
try: # some values are at X chromosome
chr_id = int(chr_id)
chr_pos = int(line[1])
_id = line[0] + ":" + line[1]
if _id in positions:
counter += 1
_imputed = {
"REF": line[3],
"ALT": line[4],
# "ALT_Frq": categorize_float(float(line[5])),
"MAF": categorize_float(float(line[6])),
"AvgCall": float(line[7]),
"Rsq": float(line[8]),
"Genotyped": line[9] == "Genotyped",
}
if line[9] == "Genotyped":
print("Genotyped", _id)
# if line[10] != "-":
# _imputed["LooRsq"] = float(line[10])
# if line[11] != "-":
# _imputed["EmpR"] = float(line[11])
# if line[12] != "-":
# _imputed["EmpRsq"] = float(line[12])
# if line[13] != "-":
# _imputed["Dose0"] = float(line[13])
# if line[14] != "-":
# _imputed["Dose1"] = float(line[14])
db.gwas.update_many({"CHR_ID": chr_id, "CHR_POS": chr_pos},
{"$set": {"imputed": {args.biobank_identifier: _imputed}}})
except:
pass
print(counter)
| from pymongo import MongoClient
import csv
import re
import argparse
def categorize_float(value):
if value <= 0.001:
return "[0,0.001]"
elif value <= 0.01:
return "(0.001,0.01]"
elif value <= 0.1:
return "(0.01,0.1]"
elif value <= 0.2:
return "(0.1,0.2]"
elif value <= 0.3:
return "(0.2,0.3]"
elif value <= 0.4:
return "(0.3,0.4]"
elif value <= 0.5:
return "(0.4,0.5]"
else:
raise ValueError
parser = argparse.ArgumentParser()
parser.add_argument("filename", help="Filename to tsv file")
parser.add_argument("biobank_identifier", help="Identifier to distinguish data in database")
args = parser.parse_args()
mongo_client = MongoClient()
db = mongo_client.gwasc
all_positions = db.gwas.find()
positions = {}
for position in all_positions:
positions["chr"+str(position["CHR_ID"])+":"+str(position["CHR_POS"])] = position
print(len(positions))
counter = 0
with open(args.filename) as tsvfile:
data = csv.reader(tsvfile, delimiter=' ')
for line in data:
chr_id = re.sub("^chr", "", line[0])
try: # some values are at X chromosome
chr_id = int(chr_id)
chr_pos = int(line[1])
_id = line[0] + ":" + line[1]
if _id in positions:
counter += 1
_imputed = {
"REF": line[3],
"ALT": line[4],
# "ALT_Frq": categorize_float(float(line[5])),
"MAF": categorize_float(float(line[6])),
"AvgCall": float(line[7]),
"Rsq": float(line[8]),
"Genotyped": line[9] == "Genotyped",
}
if line[9] == "Genotyped":
print("Genotyped", _id)
# if line[10] != "-":
# _imputed["LooRsq"] = float(line[10])
# if line[11] != "-":
# _imputed["EmpR"] = float(line[11])
# if line[12] != "-":
# _imputed["EmpRsq"] = float(line[12])
# if line[13] != "-":
# _imputed["Dose0"] = float(line[13])
# if line[14] != "-":
# _imputed["Dose1"] = float(line[14])
db.gwas.update_many({"CHR_ID": chr_id, "CHR_POS": chr_pos},
{"$set": {"imputed": {biobank_identifier: _imputed}}})
except:
pass
print(counter)
| Python | 0.00005 |
d166563f648d409f7039ce2df1149a8cb15b13ab | add sub-package: plot | gdpy3/__init__.py | gdpy3/__init__.py | __name__ = "gdpy3"
__doc__ = "gdpy3: Gyrokinetic Toroidal Code Data Processing tools"
__author__ = "shmilee"
__version__ = "0.0.1"
__status__ = "alpha"
__license__ = "MIT"
__email__ = "shmilee.zju@gmail.com"
__all__ = ['convert', 'plot', 'read']
| __name__ = "gdpy3"
__doc__ = "gdpy3: Gyrokinetic Toroidal Code Data Processing tools"
__author__ = "shmilee"
__version__ = "0.0.1"
__status__ = "alpha"
__license__ = "MIT"
__email__ = "shmilee.zju@gmail.com"
__all__ = ['convert', 'read']
| Python | 0.999514 |
f276c840f2981ec2951e07c7b847f82811db0745 | Remove unnecessary None handling | openstack/database/v1/user.py | openstack/database/v1/user.py | # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from openstack.database import database_service
from openstack import resource
class User(resource.Resource):
id_attribute = 'name'
resource_key = 'user'
resources_key = 'users'
base_path = '/instances/%(instance_id)s/users'
service = database_service.DatabaseService()
# capabilities
allow_create = True
allow_delete = True
allow_list = True
# path args
instance_id = resource.prop('instance_id')
# Properties
databases = resource.prop('databases')
name = resource.prop('name')
password = resource.prop('password')
@classmethod
def create_by_id(cls, session, attrs, r_id=None, path_args=None):
url = cls._get_url(path_args)
# Create expects an array of users
body = {'users': [attrs]}
resp = session.post(url, service=cls.service, json=body).body
return resp
| # Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from openstack.database import database_service
from openstack import resource
class User(resource.Resource):
id_attribute = 'name'
resource_key = 'user'
resources_key = 'users'
base_path = '/instances/%(instance_id)s/users'
service = database_service.DatabaseService()
# capabilities
allow_create = True
allow_delete = True
allow_list = True
# path args
instance_id = resource.prop('instance_id')
# Properties
databases = resource.prop('databases')
name = resource.prop('name')
_password = resource.prop('password')
@property
def password(self):
try:
val = self._password
except AttributeError:
val = None
return val
@password.setter
def password(self, val):
self._password = val
@classmethod
def create_by_id(cls, session, attrs, r_id=None, path_args=None):
url = cls._get_url(path_args)
# Create expects an array of users
body = {'users': [attrs]}
resp = session.post(url, service=cls.service, json=body).body
return resp
| Python | 0.000062 |
d1596872f11f95e406a6a3a97222e499abf4f222 | update plot_ts | examples/plot_ts.py | examples/plot_ts.py | """
======================
Plotting a time series
======================
Plotting a time series.
"""
import numpy as np
from scipy.stats import norm
import matplotlib.pyplot as plt
# Parameters
n_samples = 100
n_features = 48
rng = np.random.RandomState(41)
delta = 0.5
dt = 1
# Generate a toy dataset
X = (norm.rvs(scale=delta**2 * dt,
size=n_samples * n_features,
random_state=rng).reshape((n_samples, n_features)))
X[:, 0] = 0
X = np.cumsum(X, axis=1)
# Plot the first sample
plt.plot(X[0])
plt.show()
| """
======================
Plotting a time series
======================
An example plot of `pyts.visualization.plot_ts`
"""
import numpy as np
from scipy.stats import norm
from pyts.visualization import plot_ts
# Parameters
n_samples = 100
n_features = 48
rng = np.random.RandomState(41)
delta = 0.5
dt = 1
# Generate a toy dataset
X = (norm.rvs(scale=delta**2 * dt, size=n_samples*n_features, random_state=rng)
.reshape((n_samples, n_features)))
X[:, 0] = 0
X = np.cumsum(X, axis=1)
# Plot the first sample
plot_ts(X[0])
| Python | 0.000001 |
c9762ec881fc041eafb0b8906242cefcdbc4bf7f | Add UsageRecord class | accloudtant/__main__.py | accloudtant/__main__.py | import csv
class UsageRecord(object):
def __init__(self, data):
self._data = data
def __getitem__(self, key):
return self._data[key]
def area(entry):
if entry[" UsageType"].startswith("EUC1-"):
return "EU (Frankfurt)"
def is_data_transfer(entry):
if "DataTransfer" in entry[" UsageType"] or "CloudFront" in entry[" UsageType"]:
return True
return False
def get_areas(entries, resource_areas):
areas = {}
for entry in entries:
area_name = area(entry)
if area_name is None and entry[" Resource"] in resource_areas:
area_name = resource_areas[entry[" Resource"]]
if area_name not in areas:
areas[area_name] = []
areas[area_name].append(entry)
return areas
def get_data_transfers(entries):
return [entry for entry in entries if is_data_transfer(entry)]
def get_concepts(entries, omit=lambda x: False):
concepts = {}
for entry in entries:
if not omit(entry):
if entry[" UsageType"] not in concepts:
concepts[entry[" UsageType"]] = []
concepts[entry[" UsageType"]].append(entry)
return concepts
def get_total(entries):
if entries[0][" UsageType"].endswith("ByteHrs"):
totals = {}
for entry in entries:
if entry[" UsageValue"] not in totals:
totals[entry[" UsageValue"]] = []
totals[entry[" UsageValue"]].append(entry)
total = 0
for value, values in totals.items():
total += int(value) * len(values) / 24
return total / 1073741824 / len(entries)
elif entries[0][" UsageType"].endswith("Bytes"):
return sum([int(entry[" UsageValue"]) for entry in entries]) / 1073741824
return sum([int(entry[" UsageValue"]) for entry in entries])
def unit(concept):
if concept.endswith("ByteHrs"):
return "GB-Mo"
elif concept.endswith("Bytes"):
return "GB"
return "Requests"
if __name__ == "__main__":
usage = []
resource_areas = {}
with open("tests/fixtures/2021/03/S3.csv") as f:
reader = csv.DictReader(f)
for row in reader:
entry = UsageRecord(row)
usage.append(entry)
if area(entry) is not None:
resource_areas[entry[" Resource"]] = area(entry)
print("Simple Storage Service")
for area_name, entries in get_areas(usage, resource_areas).items():
print("\t", area_name)
for concept, records in get_concepts(entries, omit=lambda x: is_data_transfer(x) or x[" UsageType"] == "StorageObjectCount").items():
total = get_total(records)
print("\t\t", concept, "\t{:.3f}".format(total), unit(concept))
data_transfers = get_data_transfers(usage)
if len(data_transfers) > 0:
print("Data Transfer")
for area_name, entries in get_areas(data_transfers, resource_areas).items():
print("\t", area_name)
for concept, records in get_concepts(entries, omit=lambda x: not is_data_transfer(x)).items():
total = get_total(records)
print("\t\t", concept, "\t{:.3f}".format(total), unit(concept))
| import csv
def area(entry):
if entry[" UsageType"].startswith("EUC1-"):
return "EU (Frankfurt)"
def is_data_transfer(entry):
if "DataTransfer" in entry[" UsageType"] or "CloudFront" in entry[" UsageType"]:
return True
return False
def get_areas(entries, resource_areas):
areas = {}
for entry in entries:
area_name = area(entry)
if area_name is None and entry[" Resource"] in resource_areas:
area_name = resource_areas[entry[" Resource"]]
if area_name not in areas:
areas[area_name] = []
areas[area_name].append(entry)
return areas
def get_data_transfers(entries):
return [entry for entry in entries if is_data_transfer(entry)]
def get_concepts(entries, omit=lambda x: False):
concepts = {}
for entry in entries:
if not omit(entry):
if entry[" UsageType"] not in concepts:
concepts[entry[" UsageType"]] = []
concepts[entry[" UsageType"]].append(entry)
return concepts
def get_total(entries):
if entries[0][" UsageType"].endswith("ByteHrs"):
totals = {}
for entry in entries:
if entry[" UsageValue"] not in totals:
totals[entry[" UsageValue"]] = []
totals[entry[" UsageValue"]].append(entry)
total = 0
for value, values in totals.items():
total += int(value) * len(values) / 24
return total / 1073741824 / len(entries)
elif entries[0][" UsageType"].endswith("Bytes"):
return sum([int(entry[" UsageValue"]) for entry in entries]) / 1073741824
return sum([int(entry[" UsageValue"]) for entry in entries])
def unit(concept):
if concept.endswith("ByteHrs"):
return "GB-Mo"
elif concept.endswith("Bytes"):
return "GB"
return "Requests"
if __name__ == "__main__":
usage = []
resource_areas = {}
with open("tests/fixtures/2021/03/S3.csv") as f:
reader = csv.DictReader(f)
for row in reader:
usage.append(row)
if area(row) is not None:
resource_areas[row[" Resource"]] = area(row)
print("Simple Storage Service")
for area_name, entries in get_areas(usage, resource_areas).items():
print("\t", area_name)
for concept, records in get_concepts(entries, omit=lambda x: is_data_transfer(x) or x[" UsageType"] == "StorageObjectCount").items():
total = get_total(records)
print("\t\t", concept, "\t{:.3f}".format(total), unit(concept))
data_transfers = get_data_transfers(usage)
if len(data_transfers) > 0:
print("Data Transfer")
for area_name, entries in get_areas(data_transfers, resource_areas).items():
print("\t", area_name)
for concept, records in get_concepts(entries, omit=lambda x: not is_data_transfer(x)).items():
total = get_total(records)
print("\t\t", concept, "\t{:.3f}".format(total), unit(concept))
| Python | 0 |
78deea6602671917c5cc78de8ed20e6825179948 | add PATCH support | coyote_framework/requests/requestdriver.py | coyote_framework/requests/requestdriver.py | """
Wrapper for python's "requests" library that has options to maintain session
and keep a history of responses in a queue
"""
import requests
from collections import deque
class RequestDriver(object):
GET = 'GET'
POST = 'POST'
PUT = 'PUT'
PATCH = 'PATCH'
DELETE = 'DELETE'
session = None
responses = deque([])
max_response_history = 100
def __init__(self, persist_session_between_requests=True, max_response_history=None, verify_certificates=False):
self.persist_session_between_requests = persist_session_between_requests
self.verify_certificates = verify_certificates
if max_response_history is not None:
if not max_response_history >= 0:
raise ValueError('You must specify a positive integer as a max number of past requests to store')
if self.persist_session_between_requests:
self.session = requests.Session()
else:
self.session = requests
def request(self, uri, method=GET, headers=None, cookies=None, params=None, data=None, post_files=None,**kwargs):
"""Makes a request using requests
@param uri: The uri to send request
@param method: Method to use to send request
@param headers: Any headers to send with request
@param cookies: Request cookies (in addition to session cookies)
@param params: Request parameters
@param data: Request data
@param kwargs: other options to pass to underlying request
@rtype: requests.Response
@return: The response
"""
coyote_args = {
'headers': headers,
'cookies': cookies,
'params': params,
'files': post_files,
'data': data,
'verify': self.verify_certificates,
}
coyote_args.update(kwargs)
if method == self.POST:
response = self.session.post(uri, **coyote_args)
elif method == self.PUT:
response = self.session.put(uri, **coyote_args)
elif method == self.PATCH:
response = self.session.patch(uri, **coyote_args)
elif method == self.DELETE:
response = self.session.delete(uri, **coyote_args)
else: # Default to GET
response = self.session.get(uri, **coyote_args)
self.responses.append(response)
while len(self.responses) > self.max_response_history:
self.responses.popleft()
return response
def get_last_response(self):
"""Convenience method for retrieving the last response"""
try:
return self.responses[-1]
except IndexError:
return None
def wipe_session(self):
"""Sets the driver's session to a new request session
@return: None
"""
self.session = requests.Session()
def save_last_response_to_file(self, filename):
"""Saves the body of the last response to a file
@param filename: Filename to save to
@return: Returns False if there is an OS error, True if successful
"""
response = self.get_last_response()
return self.save_response_to_file(response, filename)
def save_response_to_file(self, response, filename):
"""Saves the body of the last response to a file
@param filename: Filename to save to
@return: Returns False if there is an OS error, True if successful
"""
try:
last_response = self.get_last_response()
with open(filename, 'w') as f:
f.write(last_response.content)
except OSError, e:
return False
return True | """
Wrapper for python's "requests" library that has options to maintain session
and keep a history of responses in a queue
"""
import requests
from collections import deque
class RequestDriver(object):
GET = 'GET'
POST = 'POST'
PUT = 'PUT'
DELETE = 'DELETE'
session = None
responses = deque([])
max_response_history = 100
def __init__(self, persist_session_between_requests=True, max_response_history=None, verify_certificates=False):
self.persist_session_between_requests = persist_session_between_requests
self.verify_certificates = verify_certificates
if max_response_history is not None:
if not max_response_history >= 0:
raise ValueError('You must specify a positive integer as a max number of past requests to store')
if self.persist_session_between_requests:
self.session = requests.Session()
else:
self.session = requests
def request(self, uri, method=GET, headers=None, cookies=None, params=None, data=None, post_files=None,**kwargs):
"""Makes a request using requests
@param uri: The uri to send request
@param method: Method to use to send request
@param headers: Any headers to send with request
@param cookies: Request cookies (in addition to session cookies)
@param params: Request parameters
@param data: Request data
@param kwargs: other options to pass to underlying request
@rtype: requests.Response
@return: The response
"""
coyote_args = {
'headers': headers,
'cookies': cookies,
'params': params,
'files': post_files,
'data': data,
'verify': self.verify_certificates,
}
coyote_args.update(kwargs)
if method == self.POST:
response = self.session.post(uri, **coyote_args)
elif method == self.PUT:
response = self.session.put(uri, **coyote_args)
elif method == self.DELETE:
response = self.session.delete(uri, **coyote_args)
else: # Default to GET
response = self.session.get(uri, **coyote_args)
self.responses.append(response)
while len(self.responses) > self.max_response_history:
self.responses.popleft()
return response
def get_last_response(self):
"""Convenience method for retrieving the last response"""
try:
return self.responses[-1]
except IndexError:
return None
def wipe_session(self):
"""Sets the driver's session to a new request session
@return: None
"""
self.session = requests.Session()
def save_last_response_to_file(self, filename):
"""Saves the body of the last response to a file
@param filename: Filename to save to
@return: Returns False if there is an OS error, True if successful
"""
response = self.get_last_response()
return self.save_response_to_file(response, filename)
def save_response_to_file(self, response, filename):
"""Saves the body of the last response to a file
@param filename: Filename to save to
@return: Returns False if there is an OS error, True if successful
"""
try:
last_response = self.get_last_response()
with open(filename, 'w') as f:
f.write(last_response.content)
except OSError, e:
return False
return True | Python | 0 |
28e64a576a25b7fb41997da8ecfb4472d9adee38 | simplify main greenlet caching | greenhouse/compat.py | greenhouse/compat.py | import os
import sys
try:
from greenlet import greenlet, GreenletExit
except ImportError, error:
try:
from py.magic import greenlet
GreenletExit = greenlet.GreenletExit
except ImportError:
# suggest standalone greenlet, not the old py.magic.greenlet
raise error
__all__ = ["main_greenlet", "GreenletExit"]
# it's conceivable that we might not be in the main greenlet at import time,
# so chase the parent tree until we get to it
main_greenlet = getcurrent()
while main_greenlet.parent:
main_greenlet = main_greenlet.parent
| import os
import sys
try:
from greenlet import greenlet, GreenletExit
except ImportError, error:
try:
from py.magic import greenlet
GreenletExit = greenlet.GreenletExit
except ImportError:
# suggest standalone greenlet, not the old py.magic.greenlet
raise error
__all__ = ["main_greenlet", "GreenletExit"]
# it's conceivable that we might not be in the main greenlet at import time,
# so chase the parent tree until we get to it
def _find_main():
glet = greenlet.getcurrent()
while glet.parent:
glet = glet.parent
return glet
main_greenlet = _find_main()
| Python | 0.000269 |
da8aa20292e0df938f0e49884b21f08034b9f441 | fix typo | google_auth/authentication.py | google_auth/authentication.py | # -*- coding: utf-8 -*-
import requests
import httplib2
from datetime import datetime, timedelta
from django.conf import settings
from django.contrib.auth import get_user_model
from django.utils.timezone import make_aware
from rest_framework import exceptions, authentication, HTTP_HEADER_ENCODING
from rest_framework.authentication import BaseAuthentication, get_authorization_header
from .models import get_users_by_email, get_google_auth_user_by_app_token
token_verification_url = 'https://www.googleapis.com/oauth2/v1/tokeninfo?access_token={}'
refresh_token_url = 'https://www.googleapis.com/oauth2/v4/token'
client_id = getattr(settings, 'GOOGLE_AUTH_CLIENT_ID', '')
client_secret = getattr(settings, 'GOOGLE_AUTH_CLIENT_SECRET', '')
class GoogleAuthBackend(object):
"""
Authenticate all requests against google, so that when the access token is revoked, the user will lose access immediately.
Pass the access token in the header of the request, like:
Authentication: token TOKEN
"""
def authenticate(self, request, token=None):
r = requests.get(token_verification_url.format(token))
if r.status_code != 200:
return None
acc_info = r.json()
email = acc_info.get('email','')
user = get_users_by_email(email)
return user
def get_user(self, user_id):
try:
return get_user_model.objects.get(pk=user_id)
except User.DoesNotExist:
return None
class GoogleAuthAuthentication(BaseAuthentication):
"""
Returns two-tuple of (user, token) if authentication succeeds,
or None otherwise.
"""
def authenticate(self, request):
auth_header = get_authorization_header(request).decode(HTTP_HEADER_ENCODING)
auth = auth_header.split()
if not auth or auth[0].lower() != 'token':
return None
if len(auth)!=2:
msg = 'Invalid authorization header.'
raise exceptions.AuthenticationFailed(msg)
app_token = auth[1]
google_auth_user = get_google_auth_user_by_app_token(app_token)
if not google_auth_user:
return None
if google_auth_user.token_expiry < make_aware(datetime.now()):
google_auth_user = refresh_access_token(google_auth_user)
token = google_auth_user.access_token
r = requests.get(token_verification_url.format(token))
if r.status_code != 200:
return None
acc_info = r.json()
email = acc_info.get('email','')
user = get_users_by_email(email)
return user, token
def refresh_access_token(google_auth_user):
r = requests.post(refresh_token_url, data = {'client_id':client_id,
'client_secret':client_secret,
'refresh_token':google_auth_user.refresh_token,
'grant_type':'refresh_token'})
if r.status_code != 200:
raise Exception('user google auth token is expired and unnable to be refreshed')
res = r.json()
google_auth_user.access_token = res.get('access_token','')
google_auth_user.token_expiry = make_aware(
datetime.now() + timedelta(seconds=
res.get('expires_in',0) - 10
))
google_auth_user.save()
return google_auth_user
| # -*- coding: utf-8 -*-
import requests
import httplib2
from datetime import datetime, timedelta
from django.conf import settings
from django.contrib.auth import get_user_model
from django.utils.timezone import make_aware
from rest_framework import exceptions, authentication, HTTP_HEADER_ENCODING
from rest_framework.authentication import BaseAuthentication, get_authorization_header
from .models import get_users_by_email, get_google_auth_user_by_app_token
token_verification_url = 'https://www.googleapis.com/oauth2/v1/tokeninfo?access_token={}'
refresh_token_url = 'https://www.googleapis.com/oauth2/v4/token'
client_id = getattr(settings, 'GOOGLE_AUTH_CLIENT_ID', '')
client_secret = getattr(settings, 'GOOGLE_AUTH_CLIENT_SECRET', '')
class GoogleAuthBackend(object):
"""
Authenticate all requests against google, so that when the access token is revoked, the user will lose access immediately.
Pass the access token in the header of the request, like:
Authentication: token TOKEN
"""
def authenticate(self, request, token=None):
r = requests.get(token_verification_url.format(token))
if r.status_code != 200:
return None
acc_info = r.json()
email = acc_info.get('email','')
user = get_users_by_email(email)
return user
def get_user(self, user_id):
try:
return get_user_model.objects.get(pk=user_id)
except User.DoesNotExist:
return None
class GoogleAuthAuthentication(BaseAuthentication):
"""
Returns two-tuple of (user, token) if authentication succeeds,
or None otherwise.
"""
def authenticate(self, request):
auth_header = get_authorization_header(request).decode(HTTP_HEADER_ENCODING)
auth = auth_header.split()
if not auth or auth[0].lower() != 'token':
return None
if len(auth)!=2:
msg = 'Invalid authorization header.'
raise exceptions.AuthenticationFailed(msg)
app_token = auth[1]
google_auth_user = get_google_auth_user_by_app_token(app_token)
if not google_auth_user:
return None
if google_auth_user.token_expiry < make_aware(datetime.now()):
google_auth_use = refresh_access_token(google_auth_user)
token = google_auth_user.access_token
r = requests.get(token_verification_url.format(token))
if r.status_code != 200:
return None
acc_info = r.json()
email = acc_info.get('email','')
user = get_users_by_email(email)
return user, token
def refresh_access_token(google_auth_user):
r = requests.post(refresh_token_url, data = {'client_id':client_id,
'client_secret':client_secret,
'refresh_token':google_auth_user.refresh_token,
'grant_type':'refresh_token'})
if r.status_code != 200:
raise Exception('user google auth token is expired and unnable to be refreshed')
res = r.json()
google_auth_user.access_token = res.get('access_token','')
google_auth_user.token_expiry = make_aware(
datetime.now() + timedelta(seconds=
res.get('expires_in',0) - 10
))
google_auth_user.save()
return google_auth_user
| Python | 0.999991 |
38989bf6e449bf2ada1ac4729564d9feacbc7b90 | use parseargs for cli processing | activity/activitylog.py | activity/activitylog.py | from peewee import *
from pprint import pprint
from copy import copy
import sys, os, inspect
import optparse
import argparse
db = SqliteDatabase('activitylog.db')
################
# Model classes
################
class BaseModel(Model):
is_abstract = BooleanField(default=False)
class Meta:
database = db
class NamedModel(BaseModel):
name = CharField(primary_key=True)
class Person(NamedModel):
first = CharField()
last = CharField()
born = DateField()
class ActivityType(NamedModel):
parent = ForeignKeyField('self', null=True, related_name='children')
class MeasurementType(NamedModel):
parent = ForeignKeyField('self', null=True, related_name='children')
class Location(NamedModel):
address = CharField()
class Entry(BaseModel):
person = ForeignKeyField(Person)
location = ForeignKeyField(Location)
props = CharField(null=True)
class Activity(Entry):
start = DateTimeField()
end = DateTimeField()
activityType = ForeignKeyField(ActivityType)
distance = IntegerField(default=0)
class Measurement(Entry):
time = DateTimeField()
measurementType = ForeignKeyField(MeasurementType)
value = DecimalField()
############
# Functions
############
def main(argv):
args = parse_args();
if args.list:
lsModel(args.list)
elif (args.list_all):
for table in db.get_tables():
print table.title()
else:
script = os.path.basename(__file__)
print "%s: you must specify an option" % script
exit(2)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--list", metavar='<model-class>', dest='list',
help='List model objects for the specified class')
parser.add_argument('--list-all', dest='list_all', action='store_true',
help='List all model classes')
return parser.parse_args()
def lsModel(clazzStr):
clazz = globals()[clazzStr]
for item in clazz.select():
if item.is_abstract == False:
attrs = copy(vars(item)['_data'])
del(attrs['is_abstract'])
pprint(attrs)
if __name__ == '__main__':
main(sys.argv[1:])
| from peewee import *
from pprint import pprint
from copy import copy
import sys, getopt, os, inspect
db = SqliteDatabase('activitylog.db')
################
# Model classes
################
class BaseModel(Model):
is_abstract = BooleanField(default=False)
class Meta:
database = db
class NamedModel(BaseModel):
name = CharField(primary_key=True)
class Person(NamedModel):
first = CharField()
last = CharField()
born = DateField()
class ActivityType(NamedModel):
parent = ForeignKeyField('self', null=True, related_name='children')
class MeasurementType(NamedModel):
parent = ForeignKeyField('self', null=True, related_name='children')
class Location(NamedModel):
address = CharField()
class Entry(BaseModel):
person = ForeignKeyField(Person)
location = ForeignKeyField(Location)
props = CharField(null=True)
class Activity(Entry):
start = DateTimeField()
end = DateTimeField()
activityType = ForeignKeyField(ActivityType)
distance = IntegerField(default=0)
class Measurement(Entry):
time = DateTimeField()
measurementType = ForeignKeyField(MeasurementType)
value = DecimalField()
############
# Functions
############
def main(argv):
try:
opts, args = getopt.getopt(argv, "", ["list=", "list-all"])
if not opts:
usage()
except getopt.GetoptError:
usage()
for opt, arg in opts:
if opt == '--list':
lsModel(arg)
elif opt == '--list-all':
for table in db.get_tables():
print table.title()
else:
usage()
def usage():
script = os.path.basename(__file__)
print "%s --ls <modelClass>" % script
sys.exit(2)
def lsModel(clazzStr):
clazz = globals()[clazzStr]
for item in clazz.select():
if item.is_abstract == False:
attrs = copy(vars(item)['_data'])
del(attrs['is_abstract'])
pprint(attrs)
if __name__ == '__main__':
main(sys.argv[1:])
| Python | 0 |
4565c961eca6f0d904d010cbdbf3d42fe2a6080b | Add persistence test | test/rlite.py | test/rlite.py | # coding=utf-8
from unittest import *
import os.path
import sys
import hirlite
class RliteTest(TestCase):
def setUp(self):
self.rlite = hirlite.Rlite()
def test_none(self):
self.assertEquals(None, self.rlite.command('get', 'hello'))
def test_ok(self):
self.assertEquals(True, self.rlite.command('set', 'hello', 'world'))
def test_string(self):
self.rlite.command('set', 'hello', 'world')
self.assertEquals('world', self.rlite.command('get', 'hello'))
def test_integer(self):
self.assertEquals(2, self.rlite.command('lpush', 'list', 'value', 'other value'))
def test_error(self):
self.assertIsInstance(self.rlite.command('set', 'key'), hirlite.HirliteError)
def test_array(self):
self.rlite.command('rpush', 'mylist', '1', '2', '3')
self.assertEquals(self.rlite.command('lrange', 'mylist', 0, -1), ['1', '2', '3'])
class PersistentTest(TestCase):
PATH = 'rlite.rld'
def setUp(self):
if os.path.exists(PersistentTest.PATH):
os.unlink(PersistentTest.PATH)
self.rlite = hirlite.Rlite(PersistentTest.PATH)
def tearDown(self):
if os.path.exists(PersistentTest.PATH):
os.unlink(PersistentTest.PATH)
def test_write_close_open(self):
self.rlite.command('set', 'key', 'value')
self.rlite = hirlite.Rlite(PersistentTest.PATH) # close db, open a new one
self.assertEquals('value', self.rlite.command('get', 'key'))
| # coding=utf-8
from unittest import *
import hirlite
import sys
class RliteTest(TestCase):
def setUp(self):
self.rlite = hirlite.Rlite()
def test_none(self):
self.assertEquals(None, self.rlite.command('get', 'hello'))
def test_ok(self):
self.assertEquals(True, self.rlite.command('set', 'hello', 'world'))
def test_string(self):
self.rlite.command('set', 'hello', 'world')
self.assertEquals('world', self.rlite.command('get', 'hello'))
def test_integer(self):
self.assertEquals(2, self.rlite.command('lpush', 'list', 'value', 'other value'))
def test_error(self):
self.assertIsInstance(self.rlite.command('set', 'key'), hirlite.HirliteError)
def test_array(self):
self.rlite.command('rpush', 'mylist', '1', '2', '3')
self.assertEquals(self.rlite.command('lrange', 'mylist', 0, -1), ['1', '2', '3'])
| Python | 0.00001 |
b451a8546d52ab80186938219a99853f3fb7ff31 | Add more in Tk GUI tool, to fix in the layout. | HearthStone/HearthStone/gui_tools/tkgui.py | HearthStone/HearthStone/gui_tools/tkgui.py | #! /usr/bin/python
# -*- coding: utf-8 -*-
from functools import wraps
from tkinter import *
from tkinter.ttk import *
from ..game_events import GameBegin, GameEnd, TurnEnd, SummonMinion
__author__ = 'fyabc'
class GameWindow(Frame):
"""The Tk game window.
"""
# [NOTE] Some rules of the variable's name in the layout:
# There are two players in the game. I am Player 0, opponent is Player 1.
# `self.deck_frame_0`, `self.deck_frame_1`
# [NOTE] Selection states:
# 0 = not anything selected
# n = n objects selected
def __init__(self, game, master=None):
super(GameWindow, self).__init__(master=master, borderwidth=30)
self.pack(fill=BOTH)
self.game = game
self.selection_state = 0
########
# Menu #
########
self.menu_bar = Menu(self.master)
self.master.config(menu=self.menu_bar)
# All cascade menus.
self.cascade_menus = {
'Game': Menu(self.menu_bar),
'Help': Menu(self.menu_bar),
}
self.menu_bar.add_cascade(label='Game', menu=self.cascade_menus['Game'])
self.menu_bar.add_command(label='Game Begin', command=self.game_begin)
self.menu_bar.add_command(label='Refresh', command=self.refresh_window)
self.menu_bar.add_cascade(label='Help', menu=self.cascade_menus['Help'])
self.menu_bar.add_command(label='Quit', command=self.quit)
###############################
# Window Layout. #
# #
# ----------------------- #
# | | . . | | #
# ----------------------- #
# | | . . | | #
# ----------------------- #
# #
###############################
########################
# Left: History frame. #
########################
self.history_frame = Frame(self, borderwidth=10)
self.history_frame.grid(row=0, column=0, columnspan=2)
#############################
# Center: Game board frame. #
#############################
self.board_frame = Frame(self, borderwidth=10)
self.board_frame.grid(row=0, column=1, rowspan=8, columnspan=2)
self.minion_button = Button(self.board_frame, text='Minion 1\nMinion 2')
self.minion_button.pack()
######################
# Right: Deck frame. #
######################
self.deck_number = [IntVar(self, 0), IntVar(self, 0)]
# Labels of deck numbers.
self.deck_label_0 = Label(
self,
borderwidth=10,
textvariable=self.deck_number[0]
)
self.deck_label_0.grid(row=0, column=9)
self.deck_label_1 = Label(
self,
borderwidth=10,
textvariable=self.deck_number[1]
)
self.deck_label_1.grid(row=1, column=9)
############################
# Some initial operations. #
############################
self.refresh_window()
def refresh_window(self):
"""Refresh all elements of the game window."""
self.refresh_minions()
self.refresh_deck()
def refresh_minions(self):
for element in self.board_frame.winfo_children():
element.destroy()
for i in (0, 1):
player = self.game.players[i]
for n, card in enumerate(player.desk):
minion_button = Button(self.board_frame, text='Minion\n{}'.format(i))
minion_button.grid(row=2 if i == 0 else 1, column=n)
for n, card in enumerate(player.hand):
minion_button = Button(self.board_frame, text='Minion\n{}'.format(i))
minion_button.grid(row=3 if i == 0 else 0, column=n)
def refresh_deck(self):
for i in (0, 1):
self.deck_number[i].set(self.game.players[i].deck_number)
def _add_select(self):
self.selection_state += 1
def _clear_select(self):
self.selection_state = 0
# Some user operations.
def game_begin(self):
self.game.dispatch_event_quick(GameBegin)
self.refresh_window()
__all__ = [
'GameWindow',
]
| #! /usr/bin/python
# -*- coding: utf-8 -*-
import tkinter as tk
__author__ = 'fyabc'
class GameWindow(tk.Frame):
def __init__(self, game, master=None):
super(GameWindow, self).__init__(master=master, borderwidth=30)
self.pack(fill=tk.BOTH)
self.game = game
########
# Menu #
########
self.menu_bar = tk.Menu(self.master)
self.master.config(menu=self.menu_bar)
# All cascade menus.
self.cascade_menus = {
'Game': tk.Menu(self.menu_bar),
'Help': tk.Menu(self.menu_bar),
}
self.menu_bar.add_cascade(label='Game', menu=self.cascade_menus['Game'])
self.menu_bar.add_cascade(label='Help', menu=self.cascade_menus['Help'])
self.menu_bar.add_command(label='Quit', command=self.quit)
##################
# Window Layout. #
##################
########################
# Left: History frame. #
########################
self.history_frame = tk.Frame(self, borderwidth=0)
self.history_frame.pack(side=tk.LEFT)
#############################
# Center: Game board frame. #
#############################
self.board_frame = tk.Frame(self, borderwidth=0)
self.board_frame.pack(side=tk.LEFT)
######################
# Right: Deck frame. #
######################
self.deck_frame = tk.Frame(self, borderwidth=0)
self.deck_frame.pack(side=tk.RIGHT)
self.deck_labels = [
tk.Label(self.deck_frame,
text='Hello'),
tk.Label(self.deck_frame,
text='World'),
]
self.deck_labels[0].pack(
side=tk.TOP,
fill=tk.BOTH,
expand=True,
)
self.deck_labels[1].pack(
side=tk.BOTTOM,
fill=tk.BOTH,
expand=True,
)
__all__ = [
'GameWindow',
]
| Python | 0 |
18428461f230d7d57056bd1a6a0fc2a66cedb5f1 | increment version | grizli/version.py | grizli/version.py | # git describe --tags
__version__ = "0.8.0-14-g548f692"
| # git describe --tags
__version__ = "0.8.0-10-g15486e6"
| Python | 0.000004 |
b66c987170d8d0b6b83d25f4214208b9251c644c | Document error handling | code/document.py | code/document.py | from boto.s3.key import Key
import socket
import sys
import xmltodict
from collections import OrderedDict
import gzip
class Document(object):
"""
This class represents a subtitle file.
"""
def __init__(self, key, label):
self.label = label
self.key = key
self.parsed_xml = self.parse_xml()
self.contents = self.extract_sub()
def get_sub(self):
"""Returns subtitle from file if it exists."""
try:
return self.contents['document']['s']
except KeyError:
print sub.keys()
def load_file(self):
if type(self.key) == Key:
filename = 'file.xml'
self.key.get_contents_to_filename('file.xml')
if self.key.name.endswith('.gz'):
return gzip.GzipFile(fileobj=open(filename, 'rb'))
else:
return open(filename,'r')
else:
filename = self.key
if filename.endswith('.gz'):
return gzip.GzipFile(fileobj=open(filename, 'rb'))
else:
return open(filename,'r')
def parse_xml(self):
"""
Loads XML file and converts to OrderedDict
"""
f = self.load_file()
# if self.key.name == 'subtitle_project,data/xml/en/1969/65063/59688.xml.gz':
# print f.read()
# try:
# return xmltodict.parse(f.read())
# except:
# return {}
# xml=''
# line = f.readline()
# while line:
# xml += line.strip()
# try:
# line = f.readline()
# except:
# ip = socket.gethostbyname(socket.gethostname())
# filename = self.key.name
# raise IOError('Unzipping error - IP: %s, file: %s' % (ip, filename))
# try:
xml_dict = xmltodict.parse(f)
# except:
# print xml
# return
f.close()
return xml_dict
def extract_row(self, row):
"""Returns informations attached to one row of a subtitle.
"""
row_id, times, words = [], [], []
if '@id' in row:
row_id = row['@id']
if 'time' in row:
times = self.flatten_row(row['time'], '@value')
if 'w' in row:
words = self.flatten_row(row['w'], '#text')
return row_id, times, words
def extract_sub(self):
"""
Returns subtitle as a list of triplets (id, timestamps, words).
"""
sentences = []
try:
doc = self.parsed_xml['document']
except AttributeError, KeyError:
return sentences
if 's' in doc.keys():
for row in doc['s']:
sentences.append(self.extract_row(row))
return sentences
def flatten_row(self, elem, field):
"""Flattens nested dictionaries in the XML file."""
if type(elem) == list:
return [e[field] for e in elem]
elif type(elem) == OrderedDict:
return [elem[field]]
def get_bag_of_words(self):
"""Returns list of all words."""
return [word for id, t, sentence in self.contents for word in sentence]
def parse_nb(self):
"""
Parameters
--------
Returns RDD of LabeledPoint objects to be trained.
"""
return (self.filename, LabeledPoint(self.label, self.vec))
| from boto.s3.key import Key
import socket
import sys
import xmltodict
from collections import OrderedDict
import gzip
class Document(object):
"""
This class represents a subtitle file.
"""
def __init__(self, key, label):
self.label = label
self.key = key
self.parsed_xml = self.parse_xml()
self.contents = self.extract_sub()
def get_sub(self):
"""Returns subtitle from file if it exists."""
try:
return self.contents['document']['s']
except KeyError:
print sub.keys()
def load_file(self):
if type(self.key) == Key:
filename = 'file.xml'
self.key.get_contents_to_filename('file.xml')
if self.key.name.endswith('.gz'):
return gzip.GzipFile(fileobj=open(filename, 'rb'))
else:
return open(filename,'r')
else:
filename = self.key
if filename.endswith('.gz'):
return gzip.GzipFile(fileobj=open(filename, 'rb'))
else:
return open(filename,'r')
def parse_xml(self):
"""
Loads XML file and converts to OrderedDict
"""
f = self.load_file()
# if self.key.name == 'subtitle_project,data/xml/en/1969/65063/59688.xml.gz':
# print f.read()
# try:
# return xmltodict.parse(f.read())
# except:
# return {}
xml=''
line = f.readline()
while line:
xml += line.strip()
line = f.readline()
try:
xml_dict = xmltodict.parse(xml)
except:
print xml
return
f.close()
return xml_dict
def extract_row(self, row):
"""Returns informations attached to one row of a subtitle.
"""
row_id, times, words = [], [], []
if '@id' in row:
row_id = row['@id']
if 'time' in row:
times = self.flatten_row(row['time'], '@value')
if 'w' in row:
words = self.flatten_row(row['w'], '#text')
return row_id, times, words
def extract_sub(self):
"""
Returns subtitle as a list of triplets (id, timestamps, words).
"""
if 'document' in self.parsed_xml.keys():
doc = self.parsed_xml['document']
else:
return []
sentences = []
if 's' in doc.keys():
for row in doc['s']:
sentences.append(self.extract_row(row))
return sentences
def flatten_row(self, elem, field):
"""Flattens nested dictionaries in the XML file."""
if type(elem) == list:
return [e[field] for e in elem]
elif type(elem) == OrderedDict:
return [elem[field]]
def get_bag_of_words(self):
"""Returns list of all words."""
return [word for id, t, sentence in self.contents for word in sentence]
def parse_nb(self):
"""
Parameters
--------
Returns RDD of LabeledPoint objects to be trained.
"""
return (self.filename, LabeledPoint(self.label, self.vec))
| Python | 0.000001 |
ac6c75bc2247e08bbcc77c931130d2c01615762b | Use a consistent object description for test models | versions_tests/models.py | versions_tests/models.py | from django.db.models import CharField
from versions.models import Versionable, VersionedManyToManyField, VersionedForeignKey
def versionable_description(obj):
return "<" + str(obj.__class__.__name__) + " object: " + str(
obj.name) + " {valid: [" + obj.version_start_date.isoformat() + " | " + (
obj.version_end_date.isoformat() if obj.version_end_date else "None") + "], created: " + obj.version_birth_date.isoformat() + "}>"
############################################
# The following model is used for:
# - CreationTest
# - DeletionTest
# - CurrentVersionTest
# - VersionedQuerySetTest
# - VersionNavigationTest
# - HistoricObjectsHandling
class B(Versionable):
name = CharField(max_length=200)
__str__ = versionable_description
############################################
# OneToManyTest models
class Team(Versionable):
name = CharField(max_length=200)
__str__ = versionable_description
class Player(Versionable):
name = CharField(max_length=200)
team = VersionedForeignKey(Team, null=True)
__str__ = versionable_description
############################################
# SelfOneToManyTest models
class Directory(Versionable):
name = CharField(max_length=100)
parent = VersionedForeignKey('self', null=True)
# ############################################
# MultiM2MTest models
class Professor(Versionable):
name = CharField(max_length=200)
address = CharField(max_length=200)
phone_number = CharField(max_length=200)
__str__ = versionable_description
class Classroom(Versionable):
name = CharField(max_length=200)
building = CharField(max_length=200)
__str__ = versionable_description
class Student(Versionable):
name = CharField(max_length=200)
professors = VersionedManyToManyField("Professor", related_name='students')
classrooms = VersionedManyToManyField("Classroom", related_name='students')
__str__ = versionable_description
############################################
# MultiM2MToSameTest models
class Pupil(Versionable):
name = CharField(max_length=200)
phone_number = CharField(max_length=200)
language_teachers = VersionedManyToManyField('Teacher', related_name='language_students')
science_teachers = VersionedManyToManyField('Teacher', related_name='science_students')
__str__ = versionable_description
class Teacher(Versionable):
name = CharField(max_length=200)
domain = CharField(max_length=200)
__str__ = versionable_description
############################################
# ManyToManyFilteringTest models
class C1(Versionable):
name = CharField(max_length=50)
c2s = VersionedManyToManyField("C2", related_name='c1s')
__str__ = versionable_description
class C2(Versionable):
name = CharField(max_length=50)
c3s = VersionedManyToManyField("C3", related_name='c2s')
__str__ = versionable_description
class C3(Versionable):
name = CharField(max_length=50)
__str__ = versionable_description
############################################
# HistoricM2MOperationsTests models
class Observer(Versionable):
name = CharField(max_length=200)
__str__ = versionable_description
class Subject(Versionable):
name = CharField(max_length=200)
observers = VersionedManyToManyField('Observer', related_name='subjects')
__str__ = versionable_description
| from django.db.models import CharField
from versions.models import Versionable, VersionedManyToManyField, VersionedForeignKey
############################################
# The following model is used for:
# - CreationTest
# - DeletionTest
# - CurrentVersionTest
# - VersionedQuerySetTest
# - VersionNavigationTest
# - HistoricObjectsHandling
class B(Versionable):
name = CharField(max_length=200)
############################################
# OneToManyTest models
class Team(Versionable):
name = CharField(max_length=200)
def __str__(self):
return "<" + str(self.__class__.__name__) + " object: " + str(
self.name) + " {valid: [" + self.version_start_date.isoformat() + " | " + (
self.version_end_date.isoformat() if self.version_end_date else "None") + "], created: " + self.version_birth_date.isoformat() + "}>"
class Player(Versionable):
name = CharField(max_length=200)
team = VersionedForeignKey(Team, null=True)
def __str__(self):
return "<" + str(self.__class__.__name__) + " object: " + str(
self.name) + " {valid: [" + self.version_start_date.isoformat() + " | " + (
self.version_end_date.isoformat() if self.version_end_date else "None") + "], created: " + self.version_birth_date.isoformat() + "}>"
############################################
# SelfOneToManyTest models
class Directory(Versionable):
name = CharField(max_length=100)
parent = VersionedForeignKey('self', null=True)
# ############################################
# MultiM2MTest models
class Professor(Versionable):
name = CharField(max_length=200)
address = CharField(max_length=200)
phone_number = CharField(max_length=200)
def __str__(self):
return self.name
class Classroom(Versionable):
name = CharField(max_length=200)
building = CharField(max_length=200)
def __str__(self):
return self.name
class Student(Versionable):
name = CharField(max_length=200)
professors = VersionedManyToManyField("Professor", related_name='students')
classrooms = VersionedManyToManyField("Classroom", related_name='students')
def __str__(self):
return self.name
############################################
# MultiM2MToSameTest models
class Pupil(Versionable):
name = CharField(max_length=200)
phone_number = CharField(max_length=200)
language_teachers = VersionedManyToManyField('Teacher', related_name='language_students')
science_teachers = VersionedManyToManyField('Teacher', related_name='science_students')
class Teacher(Versionable):
name = CharField(max_length=200)
domain = CharField(max_length=200)
############################################
# ManyToManyFilteringTest models
class C1(Versionable):
name = CharField(max_length=50)
c2s = VersionedManyToManyField("C2", related_name='c1s')
class C2(Versionable):
name = CharField(max_length=50)
c3s = VersionedManyToManyField("C3", related_name='c2s')
class C3(Versionable):
name = CharField(max_length=50)
############################################
# HistoricM2MOperationsTests models
class Observer(Versionable):
name = CharField(max_length=200)
class Subject(Versionable):
name = CharField(max_length=200)
observers = VersionedManyToManyField('Observer', related_name='subjects')
| Python | 0.000013 |
68eaa885e15b98bc05376d9ddca6926258be2c46 | make header fields with dates (e.g. last-modified) comparable | httoop/header/conditional.py | httoop/header/conditional.py | # -*- coding: utf-8 -*-
from httoop.header.element import HeaderElement
class _DateComparable(object):
from httoop.date import Date
def sanitize(self):
self.value = self.Date.parse(self.value)
class ETag(HeaderElement):
pass
class LastModified(_DateComparable, HeaderElement):
__name__ = 'Last-Modified'
class IfMatch(HeaderElement):
__name__ = 'If-Match'
class IfModifiedSince(_DateComparable, HeaderElement):
__name__ = 'If-Modified-Since'
class IfNoneMatch(HeaderElement):
__name__ = 'If-None-Match'
class IfUnmodifiedSince(_DateComparable, HeaderElement):
__name__ = 'If-Unmodified-Since'
| # -*- coding: utf-8 -*-
from httoop.header.element import HeaderElement
class ETag(HeaderElement):
pass
class LastModified(HeaderElement):
__name__ = 'Last-Modified'
class IfMatch(HeaderElement):
__name__ = 'If-Match'
class IfModifiedSince(HeaderElement):
__name__ = 'If-Modified-Since'
class IfNoneMatch(HeaderElement):
__name__ = 'If-None-Match'
class IfUnmodifiedSince(HeaderElement):
__name__ = 'If-Unmodified-Since'
| Python | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.