repo_name
stringlengths 5
100
| path
stringlengths 4
231
| language
stringclasses 1
value | license
stringclasses 15
values | size
int64 6
947k
| score
float64 0
0.34
| prefix
stringlengths 0
8.16k
| middle
stringlengths 3
512
| suffix
stringlengths 0
8.17k
|
|---|---|---|---|---|---|---|---|---|
phoenixsbk/kvmmgr
|
packaging/setup/plugins/ovirt-engine-rename/ovirt-engine/tools.py
|
Python
|
apache-2.0
| 3,586
| 0.002231
|
#
# ovirt-engine-setup -- ovirt engine setup
# Copyright (C) 2013 Red Hat, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
#
|
distributed under the License is distributed on an "AS
|
IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Tools configuration plugin."""
import os
import gettext
_ = lambda m: gettext.dgettext(message=m, domain='ovirt-engine-setup')
from otopi import constants as otopicons
from otopi import util
from otopi import filetransaction
from otopi import plugin
from ovirt_engine_setup import constants as osetupcons
from ovirt_engine_setup.engine import constants as oenginecons
from ovirt_engine_setup.engine_common \
import constants as oengcommcons
@util.export
class Plugin(plugin.PluginBase):
"""Tools configuration plugin."""
# 'section' is not used here, left for reference - hopefully
# one day the code will be merged with the generation code
TOOLS_CONFIG = (
{
'dir': '{engine_sysconf}/isouploader.conf.d',
'section': 'ISOUploader',
},
{
'dir': '{engine_sysconf}/imageuploader.conf.d',
'section': 'ImageUploader',
},
{
'dir': '{engine_sysconf}/logcollector.conf.d',
'section': 'LogCollector',
},
)
def _entry_filename(self, entry):
return os.path.join(
entry['dir'],
'10-engine-setup.conf'
).format(
engine_sysconf=(
oenginecons.FileLocations.
OVIRT_ENGINE_SYSCONFDIR
),
)
def _content_with_renamed_fqdn(self, config):
with open(config, 'r') as f:
content = []
for line in f:
line = line.rstrip('\n')
if line.startswith('engine='):
line = (
'engine=%s:%s'
) % (
self.environment[
osetupcons.RenameEnv.FQDN
],
self.environment[
oengcommcons.ConfigEnv.PUBLIC_HTTPS_PORT
],
)
content.append(line)
return content
def __init__(self, context):
super(Plugin, self).__init__(context=context)
@plugin.event(
stage=plugin.Stages.STAGE_SETUP,
)
def _setup(self):
for entry in self.TOOLS_CONFIG:
self.environment[
osetupcons.RenameEnv.FILES_TO_BE_MODIFIED
].append(self._entry_filename(entry))
@plugin.event(
stage=plugin.Stages.STAGE_MISC,
)
def _misc(self):
for entry in self.TOOLS_CONFIG:
name = self._entry_filename(entry)
self.environment[otopicons.CoreEnv.MAIN_TRANSACTION].append(
filetransaction.FileTransaction(
name=name,
content=self._content_with_renamed_fqdn(name),
modifiedList=self.environment[
otopicons.CoreEnv.MODIFIED_FILES
],
)
)
# vim: expandtab tabstop=4 shiftwidth=4
|
zombiezen/turbohvz
|
hvz/email.py
|
Python
|
gpl-3.0
| 6,348
| 0.002205
|
#!/usr/bin/env python
#
# email.py
# TurboHvZ
#
# Copyright (C) 2008 Ross Light
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
"""
Support for email
:Variables:
cell_providers : dict
Dictionary of cell phone supported providers. Each value is a
``(name, sms_domain)`` pair.
"""
import turbogears
import turbomail
from turbomail.message import Message
__author__ = 'Ross Light'
__date__ = 'April 16, 2008'
__docformat__ = 'reStructuredText'
__all__ = ['GenshiMessage',
'sendmail',
'send_generic_mail',
'send_sms',]
cell_providers = \
{
'att': (_("AT&T"), 'mms.att.net'),
'nextel': (_("Nextel"), 'messaging.nextel.com'),
'sprint': (_("Sprint"), 'messaging.sprintpcs.com'),
't-mobile': (_("T-Mobile"), 'tmomail.net'),
'verizon': (_("Verizon"), 'vtext.com'),
'virgin': (_("Virgin Mobile"), 'vmobl.com'),
'boost': (_("Boost"), 'myboostmobile.com'),
}
class GenshiMessage(Message):
"""A message created from a Genshi template."""
def __init__(self, sender, recipient, subject, template, variables={}, **kw):
"""
Store the additonal template and variable information.
:Parameters:
template : str
A dot-path to a valid Genshi template.
variables : dict
A dictionary containing named variables to pass to the
template engine.
"""
self.plain_only = kw.pop('plain_only', False)
self._template = template
self._variables = dict(sender=sender,
recipient=recipient,
subject=subject)
self._variables.update(variables)
super(GenshiMessage, self).__init__(sender, recipient, subject, **kw)
def _process(self):
"""Automatically generate the plain and rich text content."""
turbogears.view.base.load_engines()
data = dict()
for (i, j) in self._variables.iteritems():
if callable(j):
data[i] = j()
else:
data[i] = j
engine = turbogears.view.engines.get('genshi')
encoding = turbogears.config.get('genshi.encoding', 'utf-8')
data['email_format'] = 'plain'
self.plain = engine.render(data, template=self._template,
format="text")
self.plain = self._clean_plain(self.plain)
self.plain = self.plain.decode(encoding)
if not self.plain_only:
data['email_format'] = 'rich'
self.rich = engine.render(data, template=self._template)
self.rich = self.rich.decode(encoding)
return super(GenshiMessage, self)._process()
@staticmethod
def _clean_plain(text):
text = text.strip()
lines = []
for line in text.splitlines():
line = line.strip()
try:
last_line = lines[-1]
except IndexError:
last_line = None
if line or last_line:
# Only allow one blank line between text chunks
lines.append(line)
return '\r\n'.join(lines)
def sendmail(recipient, subject, template, variables={}, **kw):
"""
Conveniently sends an email.
This will immediately return if mail has been turned off. The sender is
set to the value of the configuration value ``hvz.webmaster_email``.
:Returns: The newly created message
:ReturnType: turbomail.message.Message
"""
if not turbogears.config.get('mail.on', False):
# Mail has been turned off, ignore it.
return
variables = variables.copy()
variables.setdefault('message_format', 'email')
from_address = turbogears.config.get('hvz.webmaster_email')
new_message = GenshiMessage(from_address, recipient, subject,
template, variables, *
|
*kw)
turbomail.enqueue(new_message
|
)
return new_message
def send_generic_mail(recipients, subject, message):
"""
Conveniently sends a custom email.
This will immediately return if mail has been turned off. The sender is
set to the value of the configuration value ``hvz.webmaster_email``.
:Returns: The newly created message
:ReturnType: turbomail.message.Message
"""
return sendmail(recipients, subject, "hvz.templates.mail.generic",
dict(subject=subject,
content=message,))
def send_sms(numbers, subject, template, variables={}):
"""
Sends a text message.
:Parameters:
numbers : tuple or list of tuple
Numbers to send to. Each item must be a ``(number, provider)``
pair where number is a ten-digit US phone number.
subject : unicode
Subject to send with
template : unicode
Template to use
variables : dict
Variables to pass to template
:Returns: The newly created message
:ReturnType: turbomail.message.Message
"""
def _make_address(item):
number, provider = item
if len(number) != 10:
raise ValueError('Number is not a valid US phone number')
provider_name, provider_domain = cell_providers[provider]
return number + '@' + provider_domain
if not turbogears.config.get('hvz.notify_sms', True):
# SMS has been turned off, ignore it.
return
if isinstance(numbers, tuple):
numbers = [numbers]
addresses = [_make_address(item) for item in numbers]
variables = variables.copy()
variables.setdefault('message_format', 'sms')
return sendmail(addresses, subject, template, variables, plain_only=True)
|
liampauling/betfairlightweight
|
tests/test_scores.py
|
Python
|
mit
| 3,269
| 0.00153
|
import unittest
from unittest import mock
from betfairlightweight import APIClient
from betfairlightweight import resources
from betfairlightweight.endpoints.scores import Scores
from betfairlightweight.exceptions import APIError
from tests.tools import create_mock_json
class ScoresInit(unittest.TestCase):
def test_base_endpoint_init(self):
client = APIClient("username", "password", "app_key")
scores = Scores(client)
assert scores.connect_timeout == 3.05
assert scores._error == APIError
assert scores.client == client
assert scores.URI == "ScoresAPING/v1.0/"
class ScoresTest(unittest.TestCase):
def setUp(self):
client = APIClient("username", "password", "app_key", "UK")
self.scores = Scores(client)
@mock.patch("betfairlightweight.endpoints.scores.Scores.request")
def test_list_race_details(self, mock_response):
mock = create_mock_json("tests/resources/list_race_details.json")
mock_response.return_value = (mock.Mock(), mock.json(), 1.5)
response = self.scores.list_race_details()
assert mock.json.call_count == 1
mock_response.assert_called_with("ScoresAPING/v1.0/listRaceDetails", {}, None)
assert isinstance(response[0], resources.RaceDetails)
assert len(response) == 475
@mock.patch("betfairlightweight.endpoints.scores.Scores.request")
def test_list_available_events(self, mock_response):
mock = create_mock_json("tests/resources/availableevents.json")
mock_response.return_value = (mock.Mock(), mock.json(), 1.3)
response = self.scores.list_available_events()
assert mock.json.call_count == 1
mock_response.assert_called_with(
"ScoresAPING/v1.0/listAvailableEvents", {}, None
)
assert all(isinstance(event, resources.AvailableEvent) for event in response)
@mock.patch("betfairlightweight.endpoints.scores.Scores.request")
def test_list_scores(self, mock_response):
mock = create_mock_json("tests/resources/score.json")
mock_response.return_value = (mock.Mock(), mock.json(), 1.3)
mock_update_keys = mock.Mock()
response = self.scores.list_scores(mock_update_keys)
assert mock.json.call_count ==
|
1
mock_response.assert_called_with(
"ScoresAPING/v1.0/listScores", {"updateKeys": mock_update_keys}, None
)
assert all(isinstance(event, resources.Score)
|
for event in response)
@mock.patch("betfairlightweight.endpoints.scores.Scores.request")
def test_list_incidents(self, mock_response):
mock = create_mock_json("tests/resources/incidents.json")
mock_response.return_value = (mock.Mock(), mock.json(), 1.3)
mock_update_keys = mock.Mock()
response = self.scores.list_incidents(mock_update_keys)
assert mock.json.call_count == 1
mock_response.assert_called_with(
"ScoresAPING/v1.0/listIncidents", {"updateKeys": mock_update_keys}, None
)
assert all(isinstance(event, resources.Incidents) for event in response)
def test_url(self):
assert self.scores.url == "%s%s" % (
self.scores.client.api_uri,
"scores/json-rpc/v1",
)
|
morefigs/pymba
|
pymba/vimba_c.py
|
Python
|
mit
| 17,849
| 0.001345
|
from sys import platform as sys_plat
import platform
import os
from ctypes import *
if sys_plat == "win32":
def find_win_dll(arch):
""" Finds the highest versioned windows dll for the specified architecture. """
dlls = []
filename = 'VimbaC.dll'
# look in local working directory first
if os.path.isfile(filename):
dlls.append(filename)
if not dlls:
if 'VIMBA_HOME' in os.environ:
candidate = os.environ['VIMBA_HOME'] + r'\VimbaC\Bin\Win%i\VimbaC.dll' % (arch)
if os.path.isfile(candidate):
dlls.append(candidate)
if not dlls:
bases = [
r'C:\Program Files\Allied Vision Technologies\AVTVimba_%i.%i\VimbaC\Bin\Win%i\VimbaC.dll',
r'C:\Program Files\Allied Vision\Vimba_%i.%i\VimbaC\Bin\Win%i\VimbaC.dll'
]
for base in bases:
for major in range(4):
for minor in range(10):
candidate = base % (major, minor, arch)
if os.path.isfile(candidate):
dlls.append(candidate)
if not dlls:
raise IOError("VimbaC.dll not found.")
return dlls[-1]
if '64' in platform.architecture()[0]:
vimbaC_path = find_win_dll(64)
else:
vimbaC_path = find_win_dll(32)
dll_loader = windll
else:
dll_loader = cdll
def find_so(platform, genicam_path):
vimbaC_found = False
for tlPath in [p for p in os.environ.get(genicam_path).split(":") if p]:
vimba_dir = "/".join(tlPath.split("/")[1:-3])
vimbaC_path = "/" + vimba_dir + "/VimbaC/DynamicLib/" + platform + "/libVimbaC.so"
if os.path.isfile(vimbaC_path):
vimbaC_found = True
break
if not vimbaC_found:
raise OSError('No libVimbaC.so found')
return vimbaC_path
if 'x86_64' in os.uname()[4]:
assert os.environ.get(
"GENICAM_GENTL64_PATH"), "you need your GENICAM_GENTL64_PATH environment set. Make sure you have Vimba installed, and you have loaded the /etc/profile.d/ scripts"
vimbaC_path = find_so('x86_64bit', "GENICAM_GENTL64_PATH")
elif 'x86_32' in os.uname()[4]:
print("Warning: x86_32 reached!")
assert os.environ.get(
"GENICAM_GENTL32_PATH"), "you need your GENICAM_GENTL32_PATH environment set. Make sure you have Vimba installed, and you have loaded the /etc/profile.d/ scripts"
vimbaC_path = find_so('x86_32bit', 'GENICAM_GENTL32_PATH')
elif 'arm' in os.uname()[4]:
assert os.environ.get(
"GENICAM_GENTL32_PATH"), "you need your GENICAM_GENTL32_PATH environment set. Make sure you have Vimba installed, and you have loaded the /etc/profile.d/ scripts"
vimbaC_path = find_so('arm_32bit', 'GENICAM_GENTL32_PATH')
elif 'aarch64' in os.uname()[4]:
assert os.environ.get(
"GENICAM_GENTL64_PATH"), "you need your GENICAM_GENTL64_PATH environment set. Make sure you have Vimba installed, and you have loaded the /etc/profile.d/ scripts"
vimbaC_path = find_so('arm_64bit', "GENICAM_GENTL64_PATH")
else:
raise ValueError("Pymba currently doesn't support %s" % os.uname()[4])
# Callback function type
if sys_plat == "win32":
CALLBACK_FUNCTYPE = WINFUNCTYPE
else:
CALLBACK_FUNCTYPE = CFUNCTYPE
class NiceStructure(Structure):
def __repr__(self):
field_names = (field[0] for field in self._fields_)
return '{}({})'.format(
type(self).__name__,
", ".join("=".join((field, str(getattr(self, field))))
for field in field_names)
)
class VmbVersionInfo(NiceStructure):
_fields_ = [
('major', c_uint32),
('minor', c_uint32),
('patch', c_uint32)]
class VmbInterfaceInfo(NiceStructure):
_fields_ = [
# Unique identifier for each interface
('interfaceIdString', c_char_p),
# Interface type, see VmbInterfaceType
('interfaceType', c_uint32),
# Interface name, given by the transport layer
('interfaceName', c_char_p),
# Serial number
('serialString', c_char_p),
# Used access mode, see VmbAccessModeType
('permittedAccess', c_uint32)]
class VmbCameraInfo(NiceStructure):
_fields_ = [
# Unique identifier for each camera
('cameraIdString', c_char_p),
# Name of the camera
('cameraName', c_char_p),
# Model name
('modelName', c_char_p),
# Serial number
('serialString', c_char_p),
# Used access mode, see VmbAccessModeType
('permittedAccess', c_uint32),
# Unique value for each interface or bus
('interfaceIdString', c_char_p)]
class VmbFeatureInfo(NiceStructure):
_fields_ = [
('name', c_char_p),
('featureDataType', c_uint32),
('featureFlags', c_uint32),
('category', c_char_p),
('displayName', c_char_p),
('pollingTime', c_uint32),
('unit', c_char_p),
('representation', c_char_p),
('visibility', c_uint32),
('tooltip', c_char_p),
('description', c_char_p),
('sfncNamespace', c_char_p),
('isStreamable', c_bool),
('hasAffectedFeatures', c_bool),
('hasSelectedFeatures', c_bool)]
class VmbFrame(Structure):
_fields_ = [
# ---- IN ----
# Comprises image and ancillary data
('buffer', c_void_p),
# Size of the data buffer
('bufferSize', c_uint32),
# User context filled during queuing
('context', c_void_p * 4),
# ---- OUT ----
# Resulting status of the receive operation
('receiveStatus', c_int32),
# Resulting flags of the receive operation
('receiveFlags', c_uint32),
# Size of the image data inside the data buffer
('imageSize', c_uint32),
# Size of the ancillary data inside the data buffer
('ancillarySize', c_uint32),
# Pixel format
|
of the image
('pixelFormat', c_uint32),
# Width of an image
('width', c_uint32),
# Height of an image
('height', c_uint32),
# Horizontal offset of an image
('offsetX', c_uint32),
# Vertical offset of an image
('offsetY', c_uint32),
# Unique ID of this frame in this stream
('frameID', c_uint64),
# Timestamp of the data transfer
('timestamp', c_uint64)]
c
|
lass VimbaFeaturePersistSettings(NiceStructure):
_fields_ = [
('persistType', c_uint32),
('maxIterations', c_uint32),
('loggingLevel', c_uint32)]
_vimba_lib = dll_loader.LoadLibrary(vimbaC_path)
# ----- The below function signatures are defined in VimbaC.h -----
# callback for frame queue
vmb_frame_callback_func = CALLBACK_FUNCTYPE(None,
c_void_p,
POINTER(VmbFrame))
# Callback for Invalidation events
vmb_feature_invalidation_callback_fun = CALLBACK_FUNCTYPE(None,
c_void_p, # const VmbHandle_t handle
c_char_p, # const char* name
c_void_p) # void* pUserContext
vmb_version_query = _vimba_lib.VmbVersionQuery
vmb_version_query.restype = c_int32
vmb_version_query.argtypes = (POINTER(VmbVersionInfo),
c_uint32)
vmb_startup = _vimba_lib.VmbStartup
vmb_startup.restype = c_int32
vmb_shutdown = _vimba_lib.VmbShutdown
vmb_cameras_list = _vimba_lib.VmbCamerasList
vmb_cameras_list.restype = c_int32
vmb_cameras_list.argtypes = (POINTER(VmbCameraInfo),
c_uint32,
POINTER(c_uint32),
c_uint32)
vmb_camera_info_query = _vimba_lib.VmbCameraInfoQuery
vmb_camera_info_query.restype = c_int32
vmb_
|
Mischback/django-oweb
|
oweb/tests/views/item_update.py
|
Python
|
mit
| 10,246
| 0.001952
|
"""Contains tests for oweb.views.updates.item_update"""
# Python imports
from unittest import skip
# Django imports
from django.core.urlresolvers import reverse
from django.test.utils import override_settings
from django.contrib.auth.models import User
# app imports
from oweb.tests import OWebViewTests
from oweb.models.account import Account
from oweb.models.research import Research
from oweb.models.ship import Ship
from oweb.models.planet import Planet, Moon
from oweb.models.building import Building
from oweb.models.defense import Defense
@override_settings(AUTH_USER_MODEL='auth.User')
class OWebViewsItemUpdateTests(OWebViewTests):
def test_login_required(self):
"""Unauthenticated users should be redirected to oweb:app_login"""
r = self.client.get(reverse('oweb:item_update'))
self.assertRedirects(r,
reverse('oweb:app_login'),
status_code=302,
target_status_code=200)
def test_account_owner(self):
"""Can somebody update an item he doesn't posess?"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
res_pre = Research.objects.filter(account=acc).first()
self.client.login(username='test02', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'research',
'item_id': res_pre.id,
'item_level': res_pre.level + 1 },
HTTP_REFERER=reverse('oweb:account_research',
args=[acc.id]))
self.assertEqual(r.status_code, 403)
self.assertTemplateUsed(r, 'oweb/403.html')
def test_no_post(self):
"""What if no POST data is supplied?"""
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'))
self.assertEqual(r.status_code, 500)
self.assertTemplateUsed(r, 'oweb/500.html')
def test_research_update(self):
"""Does ``item_update()`` correctly update researches?
Basically the Django ORM can be trusted, but since there is some logic
involved in determine the correct field to update, this test is
included
"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
res_pre = Research.objects.filter(account=acc).first()
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'research',
'item_id': res_pre.id,
'item_level': res_pre.level + 1 },
HTTP_REFERER=reverse('oweb:account_research',
args=[acc.id]))
self.assertRedirects(r,
reverse('oweb:account_research', args=[acc.id]),
status_code=302,
target_status_code=200)
res_post = Research.objects.get(pk=res_pre.pk)
self.assertEqual(res_pre.level + 1, res_post.level)
def test_ship_update(self):
"""Does ``item_update()`` correctly update ships?
Basically the Django ORM can be trusted, but since there is some logic
involved in determine the correct field to update, this test is
included
"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
ship_pre = Ship.objects.filter(account=acc).first()
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'ship',
'item_id': ship_pre.id,
'item_level': ship_pre.count + 1338 },
HTTP_REFERER=reverse('oweb:account_ships',
args=[acc.id]))
self.assertRedirects(r,
reverse('oweb:account_ships', args=[acc.id]),
status_code=302,
target_status_code=200)
ship_post = Ship.objects.get(pk=ship_pre.pk)
self.assertEqual(ship_pre.count + 1338, ship_post.count)
def test_building_update(self):
"""Does ``item_update()`` correctly update buildings?
Basically the Django ORM can be trusted, but since there is some logic
involved in determine the correct field to update, this test is
included
"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
p = Planet.objects.filter(account=acc).first()
b_pre = Building.objects.filter(astro_
|
object=p).first(
|
)
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'building',
'item_id': b_pre.id,
'item_level': b_pre.level - 1 },
HTTP_REFERER=reverse('oweb:planet_buildings',
args=[p.id]))
self.assertRedirects(r,
reverse('oweb:planet_buildings', args=[p.id]),
status_code=302,
target_status_code=200)
b_post = Building.objects.get(pk=b_pre.pk)
self.assertEqual(b_pre.level - 1, b_post.level)
def test_moon_building_update(self):
"""Does ``item_update()`` correctly update moon buildings?
Basically the Django ORM can be trusted, but since there is some logic
involved in determine the correct field to update, this test is
included
"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
p = Planet.objects.filter(account=acc).values_list('id', flat=True)
m = Moon.objects.filter(planet__in=p).first()
b_pre = Building.objects.filter(astro_object=m).first()
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'moon_building',
'item_id': b_pre.id,
'item_level': b_pre.level + 2 },
HTTP_REFERER=reverse('oweb:moon_buildings',
args=[m.id]))
self.assertRedirects(r,
reverse('oweb:moon_buildings', args=[m.id]),
status_code=302,
target_status_code=200)
b_post = Building.objects.get(pk=b_pre.pk)
self.assertEqual(b_pre.level + 2, b_post.level)
def test_defense_update(self):
"""Does ``item_update()`` correctly update defense devices?
Basically the Django ORM can be trusted, but since there is some logic
involved in determine the correct field to update, this test is
included
"""
u = User.objects.get(username='test01')
acc = Account.objects.get(owner=u)
p = Planet.objects.filter(account=acc).first()
d_pre = Defense.objects.filter(astro_object=p).first()
self.client.login(username='test01', password='foo')
r = self.client.post(reverse('oweb:item_update'),
data={ 'item_type': 'defense',
'item_id': d_pre.id,
'item_level': d_pre.count - 1 },
HTTP_REFERER=reverse('oweb:planet_defense',
args=[p.id]))
self.assertRedirects(r,
reverse('oweb:planet_defense', args=[p.id]),
|
nklapste/card-py-bot
|
card_py_bot/config.py
|
Python
|
mit
| 4,162
| 0.00024
|
"""Emoji config functions"""
import json
import os
import re
from logging import getLogger
from card_py_bot import BASEDIR
__log__ = getLogger(__name__)
# Path where the emoji_config.json will be stored
EMOJI_CONFIG_PATH = os.path.join(BASEDIR, "emoji_config.json")
# Dictionary that is keyed by the Discord short emoji id and the web id
# of each emoji
MANA_ID_DICT = {
":15m:": "15",
":13m:": "13",
":wbm:": "White or Black",
":Energy:": "Energy",
":10m:": "10",
":7m:": "7",
":Untap:": "Untap",
":brm:": "Black or Red",
":bpm:": "Phyrexian Black",
":rgm:": "Red or Green",
":9m:": "9",
":8m:": "8",
":1m:": "1",
":gum:": "Green or Blue",
":2wm:": "Two or White",
":wpm:": "Phyrexian White",
":4m:": "4",
":12m:": "12",
":rm:": "Red",
":bm:": "Black",
":wum:": "White or Blue",
":rwm:": "Red or White",
":2bm:": "Two or Blue",
":gpm:": "Phyrexian Green",
":gm:": "Green",
":14m:": "14",
":bgm:": "Black or Green",
":3m:": "3",
":5m:": "5",
":Tap:": "Tap",
":1000000m:": "1000000",
":upm:": "Phyrexian Blue",
":2gm:": "Two or Green",
":rpm:": "Phyrexian Red",
":2m:": "2", ":6m:": "6",
":2rm:": "Two or Red",
":gwm:": "Green or White",
":wm:": "White",
":um:": "Blue",
":16m:": "16",
":urm:": "Blue or Red",
":ubm:": "Blue or Black",
":11m:": "11"
}
def get_emoji_config_string() -> str:
"""Return a string of all the mana ids (in order) for config setup
in discord"""
config_string = "?save_setup\n"
for short_emoji_id in MANA_ID_DICT:
config_string += ("\\\\{}\n".format(short_emoji_id))
return config_string
EMOJI_CONFIG_STRING = get_emoji_config_string()
def create_config_json() -> dict:
"""Create and save a blank default
|
config json also return the dict that
created the json"""
emoji_config = dict()
for short_emoji_id in MANA_ID_DICT:
emoji_config[short_emoji_id] = {
"web_id": MANA_ID_DICT[short_emoji_id],
"discord_raw_id":
|
None
}
with open(EMOJI_CONFIG_PATH, "w") as file:
json.dump(emoji_config, file, indent=4)
return emoji_config
def load_mana_dict() -> dict:
"""Load the emoji config into a mana dict"""
try:
with open(EMOJI_CONFIG_PATH, "r") as file:
emoji_config = json.load(file)
except FileNotFoundError:
emoji_config = create_config_json()
mana_dict = dict()
for short_emoji_id in emoji_config:
emoji = emoji_config[short_emoji_id]
if not emoji["discord_raw_id"]:
mana_dict[emoji["web_id"]] = "ERROR: NO ID Configured " \
"for {}".format(emoji["web_id"])
else:
mana_dict[emoji["web_id"]] = emoji["discord_raw_id"]
__log__.debug("WOTC Magic mana to Discord emoji "
"dictionary constructed: {}".format(mana_dict))
return mana_dict
MANA_DICT = load_mana_dict()
def parse_raw_emoji_id(raw_emoji_id: str) -> str:
"""Parse a raw emoji id to short emoji id"""
m = re.search(":[A-Za-z0-9]*:", raw_emoji_id)
return m.group(0)
def save_emoji_config(raw_emoji_ids):
"""Save the emoji mana config"""
try:
with open(EMOJI_CONFIG_PATH, "r") as file:
emoji_config = json.load(file)
except FileNotFoundError:
# if no mana config file is found initialize a new one
emoji_config = create_config_json()
for raw_emoji_id in raw_emoji_ids:
short_emoji_id = parse_raw_emoji_id(raw_emoji_id)
if short_emoji_id in MANA_ID_DICT:
emoji_config[short_emoji_id] = {
"web_id": MANA_ID_DICT[short_emoji_id],
"discord_raw_id": raw_emoji_id
}
else:
raise KeyError("Short Discord emoji id is unknown: "
"{}".format(short_emoji_id))
with open(EMOJI_CONFIG_PATH, "w") as file:
json.dump(emoji_config, file, indent=4)
# update MANA_DICT global
global MANA_DICT
MANA_DICT = load_mana_dict()
|
freakboy3742/pyxero
|
xero/basemanager.py
|
Python
|
bsd-3-clause
| 16,413
| 0.001036
|
from __future__ import unicode_literals
import json
import requests
import six
from datetime import datetime
from six.moves.urllib.parse import parse_qs
from xml.etree.ElementTree import Element, SubElement, tostring
from xml.parsers.expat import ExpatError
from .auth import OAuth2Credentials
from .exceptions import (
XeroBadRequest,
XeroExceptionUnknown,
XeroForbidden,
XeroInternalError,
XeroNotAvailable,
XeroNotFound,
XeroNotImplemented,
XeroRateLimitExceeded,
XeroTenantIdNotSet,
XeroUnauthorized,
)
from .utils import isplural, json_load_object_hook, singular
class BaseManager(object):
DECORATED_METHODS = (
"get",
"save",
"filter",
"all",
"put",
"delete",
"get_history",
"put_history",
"get_attachments",
"get_attachment_data",
"put_attachment_data",
)
OBJECT_DECORATED_METHODS = {
"Invoices": ["email", "online_invoice"],
}
DATETIME_FIELDS = (
"UpdatedDateUTC",
"Updated",
"FullyPaidOnDate",
"DateTimeUTC",
"CreatedDateUTC",
"JournalDate",
)
DATE_FIELDS = (
"DueDate",
"Date",
"PaymentDate",
"StartDate",
"EndDate",
"PeriodLockDate",
"DateOfBirth",
"OpeningBalanceDate",
"PaymentDueDate",
"ReportingDate",
"DeliveryDate",
"ExpectedArrivalDate",
)
BOOLEAN_FIELDS = (
"IsSupplier",
"IsCustomer",
"IsDemoCompany",
"PaysTax",
"IsAuthorisedToApproveTimesheets",
"IsAuthorisedToApproveLeave",
"HasHELPDebt",
"AustralianResidentForTaxPurposes",
"TaxFreeThresholdClaimed",
"HasSFSSDebt",
"EligibleToReceiveLeaveLoading",
"IsExemptFromTax",
"IsExemptFromSuper",
"SentToContact",
"IsSubscriber",
"HasAttachments",
"ShowOnCashBasisReports",
"IncludeInEmails",
"SentToContact",
"CanApplyToRevenue",
"CanApplyToLiabilities",
"CanApplyToExpenses",
"CanApplyToEquity",
"CanApplyToAssets",
"IsReconciled",
"EnablePaymentsToAccount",
"ShowInExpenseClaims",
"DiscountEnteredAsPercent",
"IsPurchased",
"IsSold",
"IsTrackedAsInventory",
)
DECIMAL_FIELDS = (
"Hours",
"NumberOfUnit",
)
INTEGER_FIELDS = (
"FinancialYearEndDay",
"FinancialYearEndMonth",
)
NO_SEND_FIELDS = (
"UpdatedDateUTC",
"HasValidationErrors",
"IsDiscounted",
"DateString",
"HasErrors",
"DueDateString",
"HasAccount",
)
OPERATOR_MAPPINGS = {
"gt": ">",
"lt": "<",
"lte": "<=",
"gte": ">=",
"ne": "!=",
}
def __init__(self):
pass
def dict_to_xml(self, root_elm, data):
for key in data.keys():
# Xero will complain if we send back these fields.
if key in self.NO_SEND_FIELDS:
continue
sub_data = data[key]
elm = SubElement(root_elm, key)
# Key references a dict. Unroll the dict
# as it's own XML node with subnodes
if isinstance(sub_data, dict):
self.dict_to_xml(elm, sub_data)
# Key references a list/tuple
elif isinstance(sub_data, list) or isinstance(sub_data, tuple):
# key name is a plural. This means each item
# in the list needs to be wrapped in an XML
# node that is a singular version of the list name.
if isplural(key):
for d in sub_data:
self.dict_to_xml(SubElement(elm, singular(key)), d)
# key name isn't a plural. Just insert the content
# as an XML node with subnodes
else:
for d in sub_data:
self.dict_to_xml(elm, d)
# Normal element - just insert the data.
else:
if key in self.BOOLEAN_FIELDS:
val = "true" if sub_data else "false"
elif key in self.DATE_FIELDS:
val = sub_data.strftime("%Y-%m-%dT%H:%M:%S")
else:
val = six.text_type(sub_data)
elm.text = val
return root_elm
def _prepare_data_for_save(self, data):
if isinstance(data, list) or isinstance(data, tuple):
root_elm = Element(self.name)
for d in data:
sub_elm = SubElement(root_elm, self.singular)
self.dict_to_xml(sub_elm, d)
else:
root_elm = self.dict_to_xml(Element(self.singular), data)
# In python3 this seems to return a bytestring
return six.u(tostring(root_elm))
def _parse_api_response(self, response, resource_name):
data = json.loads(response.text, object_hook=json_load_object_hook)
assert data["Status"] == "OK", (
"Expected the API to say OK but received %s" % data["Status"]
)
try:
return data[resource_name]
except KeyError:
return data
def _get_data(self, func):
""" This is the decorator for our DECORATED_METHODS.
Each of the decorated methods must return:
uri, params, method, body, headers, singleobject
"""
def wrapper(*args, **kwargs):
timeout = kwargs.pop("timeout", None)
uri, params, method, body, headers, singleobject = func(*args, **kwargs)
if headers is None:
headers = {}
headers["Content-Type"] = "application/xml"
if isinstance(self.credentials, OAuth2Credentials):
if self.credentials.tenant_id:
headers["Xero-tenant-id"] = self.credentials.tenant_id
else:
raise XeroTenantIdNotSet
# Use the JSON API by default, but remember we might request a PDF (application/pdf)
# so don't force the Accept header.
if "Accept" not in headers:
headers["Accept"] = "application/json"
# Set a user-agent so Xero knows the traffic is coming from pyxero
# or individual user/partner
headers["User-Agent"] = self.user_agent
response = getattr(requests, method)(
uri,
data=body,
headers=headers,
auth=self.credentials.oauth,
params=params,
timeout=timeout,
)
if response.status_code == 200:
# If we haven't got XML or JSON, assume we're being returned a
# binary file
if not response.headers["content-type"].startswith("app
|
lication/json"):
return response.content
return self._parse_api_response(response, self.name)
elif response.status_code == 204:
return response.content
elif response.status_code == 400:
try:
raise XeroBadRequest(response)
except (ValueError, ExpatError):
raise XeroExceptionUnknown(
response, msg="Unable to parse Xero AP
|
I response"
)
elif response.status_code == 401:
raise XeroUnauthorized(response)
elif response.status_code == 403:
raise XeroForbidden(response)
elif response.status_code == 404:
raise XeroNotFound(response)
elif response.status_code == 429:
limit_reason = response.headers.get("X-Rate-Limit-Problem") or "unknown"
payload = {"oauth_problem": ["rate limit exceeded: " + limit_reason],
"oauth_problem_advice": ["please wait before retrying the xero api, "
|
hannahkwarren/CLaG-Sp2016
|
code-exercises-etc/section_xx_-misc/4-2.py
|
Python
|
mit
| 419
| 0.004773
|
def pbj_while(slices):
output = ''
while (slices > 0):
slices = slic
|
es - 2
if slices >= 2:
output += 'I am making
|
a sandwich! I have bread for {0} more sandwiches.\n'.format(slices / 2)
elif slices < 2:
output += 'I am making a sandwich! But, this is my last sandwich.'
return output
print pbj_while(int(raw_input('How many slices of bread do you have? ')))
|
InfiniteAlpha/profitpy
|
profit/neuralnetdesigner/train_test.py
|
Python
|
gpl-2.0
| 3,757
| 0.003194
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 2007 Troy Melhase
# Distributed under the terms of the GNU General Public License v2
# Author: Troy Melhase <[email protected]>
import sys
from PyQt4.QtCore import QVariant
from PyQt4.QtGui import (QApplication, QFrame, QIcon,
QStandardItem, QStandardItemModel)
from profit.lib import BasicHandler
from profit.lib import Signals, tickerIdRole
from profit.lib.widgets.ui_breadfan_train import Ui_BreadFanTrainTree
class SessionTreeItem(QStandardItem):
""" Session tree item.
"""
iconNameMap = {
'account':'identity',
'connection':'server',
'messages':'view_text',
'orders':'klipper_dock',
'portfolio':'bookcase',
'strategy':'services',
'tickers':'view_detailed',
}
def __init__(self, text):
""" Constructor.
@param text value for item display
"""
QStandardItem.__init__(self, text)
self.setEditable(False)
self.setIcon(self.lookupIcon(text))
hint = self.sizeHint()
hint.setHeight(20)
self.setSizeHint(hint)
def lookupIcon(self, key):
""" Locates icon for given key.
@param key item text
@return QIcon instance
"""
try:
name = self.iconNameMap[key]
icon = QIcon(':images/icons/%s.png' % name)
except (KeyError, ):
style = QApplication.style()
icon = style.standardIcon(style.SP_DirIcon)
return icon
class SessionTreeTickerItem(SessionTreeItem):
""" Specalized session tree item for ticker symbols.
"""
def lookupIcon(self, key):
""" Locates icon for given key.
@param key ticker symbol
@return QIcon instance
"""
return QIcon(':images/tickers/%s.png' % key.lower())
def setTickerId(self, tickerId):
""" Sets item data for ticker id.
@param tickerId id for ticker as integer
@return None
"""
self.setData(QVariant(tickerId), tickerIdRole)
class SessionTreeModel(QStandardItemModel):
def __init__(self, session, parent=None):
""" Constructor.
@param session Session instance
@param parent ancestor object
"""
QStandardItemModel.__init__(self)
self.session = session
root = self.invisibleRootItem()
for key, values in session.items():
item = SessionTreeItem(key)
root.appendRow(item)
for value in values:
if key == 'tickers':
subitem = SessionTreeTickerItem(value)
subitem.setTickerId(values[value])
else:
subitem = SessionTreeItem(value)
item.appendRow(subitem)
class BreadFan
|
TrainTree(QFrame, Ui_BreadFanTrainTree):
""" Tree view of a Session object.
"""
def __init__(self, pa
|
rent=None):
""" Constructor.
@param parent ancestor of this widget
"""
QFrame.__init__(self, parent)
self.setupUi(self)
connect = self.connect
def setupBasic(self, sender, newSignal):
self.connect(sender, newSignal, self.on_newBreadNet)
def on_newBreadNet(self, net):
print '### signaled network', net
## fill and trainAlgorithm combo
algorNames = [name for name in net.train_meta]
algorCombo = self.trainAlgorithm
algorCombo.clear()
algorCombo.addItems(algorNames)
if net.trained in algorNames:
algorCombo.setCurrentIndex(algorNames.index(net.trained))
## fill params
## don't touch fill training data sources
## set training progress bar value
|
samuelgarcia/python-neo
|
neo/test/iotest/test_igorio.py
|
Python
|
bsd-3-clause
| 543
| 0
|
"""
Tests of neo.io.igorproio
"""
import unitte
|
st
try:
import igor
HAVE_IGOR = True
except ImportError:
HAVE_IGOR = False
from neo.io.igorproio import IgorIO
from neo.test.iotest.common_io_test import BaseTestIO
@unittest.skipUnless(HAVE_IGOR, "requires
|
igor")
class TestIgorIO(BaseTestIO, unittest.TestCase):
ioclass = IgorIO
entities_to_download = [
'igor'
]
entities_to_test = [
'igor/mac-version2.ibw',
'igor/win-version2.ibw'
]
if __name__ == "__main__":
unittest.main()
|
ekiwi/tinyos-1.x
|
contrib/ucb/tools/python/pytos/tools/Straw.py
|
Python
|
bsd-3-clause
| 3,841
| 0.012757
|
# "Copyright (c) 2000-2003 The Regents of the University of California.
# All rights reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose, without fee, and without written agreement
# is hereby granted, provided that the above copyright notice, the following
# two paragraphs and the author appear in all copies of this software.
#
# IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
# OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY
# OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
# ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
# PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
#
# @author Kamin Whitehouse
#
import sys, math, Queue
import pytos.tools.Drain as Drain
import pytos.Comm as Comm
from struct import *
class Straw( object ) :
def __init__( self , app ) :
self.app=app
self.linkLatency = .1
if "StrawM" not in app._moduleNames:
raise Exception("The StrawM module is not compiled into the application.")
def read(self, nodeID, strawID, start, size):
data=[] #store the data in here
response=None
while response==None:
print "pinging node %d" % nodeID
respons
|
e = self.app.StrawM.msgDataSize.peek(address=nodeID, timeout=3) #find num bytes/msg
dataSize = response[0].v
|
alue['value'].value
numHops = self.app.enums.DRAIN_MAX_TTL - response[0].getParentMsg(self.app.enums.AM_DRAINMSG).ttl
self.app.StrawM.sendPeriod.poke(self.linkLatency * numHops * 1000, address=nodeID, responseDesired=False)
msgs = [0 for i in range(int(math.ceil(size/float(dataSize))))] #keep track of straw msgs in here
msgQueue = Comm.MessageQueue(10)
Drain.getDrainObject(self.app)[0].register(self.app.msgs.StrawMsg, msgQueue)
print "Sucking %d bytes from node %d through Straw %d:" % (size, nodeID, strawID)
while msgs.count(1) < len(msgs):
subStart = msgs.index(0) * dataSize
try:
subSize = min(size, (msgs.index(1, subStart)*dataSize - subStart) )
except:
subSize = size - subStart
response = []
#while response == []:
self.app.StrawM.read(strawID, subStart, subSize, address=nodeID)
sys.stdout.write("%d-%d: " % (subStart, subStart+subSize))
numPrintedChars=0
while True :
try:
(addr, msg) = msgQueue.get(block=True, timeout=self.linkLatency * numHops * 4)
if msg.parentMsg.source == nodeID :#and msgs[msg.startIndex//dataSize] == 0:
msgs[msg.startIndex//dataSize] = 1
data[msg.startIndex:msg.startIndex+dataSize-1] = msg.data[:]
strg = ""
for i in range(numPrintedChars) :
strg += "\b"
strg += "%s/%s" % (msgs.count(1),len(msgs))
sys.stdout.write(strg)
sys.stdout.flush()
numPrintedChars = len(strg)-numPrintedChars
except Queue.Empty:
print ""
break
#now, pack the data so that it can be easily unpacked
for i in range(len(data)):
data[i] = pack('B',data[i])
return ''.join(data[0:size])
|
dbcls/dbcls-galaxy
|
lib/galaxy/web/framework/helpers/__init__.py
|
Python
|
mit
| 220
| 0.045455
|
from webhelpers import *
from dat
|
etime import datetime
def time_ago( x ):
return
|
date.distance_of_time_in_words( x, datetime.utcnow() )
def iff( a, b, c ):
if a:
return b
else:
return c
|
jredrejo/bancal
|
web2py/applications/bancal/modules/paises.py
|
Python
|
gpl-3.0
| 18,468
| 0.016688
|
# coding: utf8
Paises=(
(4, 'AF', 'AFG', 93, 'Afganistán', 'Asia', '', 'AFN', 'Afgani afgano'),
(8, 'AL', 'ALB', 355, 'Albania', 'Europa', '', 'ALL', 'Lek albanés'),
(10, 'AQ', 'ATA', 672, 'Antártida', 'Antártida', '', '', ''),
(12, 'DZ', 'DZA', 213, 'Argelia', 'África', '', 'DZD', 'Dinar algerino'),
(16, 'AS', 'ASM', 1684, 'Samoa Americana', 'Oceanía', '', '', ''),
(20, 'AD', 'AND', 376, 'Andorra', 'Europa', '', 'EUR', 'Euro'),
(24, 'AO', 'AGO', 244, 'Angola', 'África', '', 'AOA', 'Kwanza angoleño'),
(28, 'AG', 'ATG', 1268, 'Antigua y Barbuda', 'América', 'El Caribe', '', ''),
(31, 'AZ', 'AZE', 994, 'Azerbaiyán', 'Asia', '', 'AZM', 'Manat azerbaiyano'),
(32, 'AR', 'ARG', 54, 'Argentina', 'América', 'América del Sur', 'ARS', 'Peso argentino'),
(36, 'AU', 'AUS', 61, 'Australia', 'Oceanía', '', 'AUD', 'Dólar australiano'),
(40, 'AT', 'AUT', 43, 'Austria', 'Europa', '', 'EUR', 'Euro'),
(44, 'BS', 'BHS', 1242, 'Bahamas', 'América', 'El Caribe', 'BSD', 'Dólar bahameño'),
(48, 'BH', 'BHR', 973, 'Bahréin', 'Asia', '', 'BHD', 'Dinar bahreiní'),
(50, 'BD', 'BGD', 880, 'Bangladesh', 'Asia', '', 'BDT', 'Taka de Bangladesh'),
(51, 'AM', 'ARM', 374, 'Armenia', 'Asia', '', 'AMD', 'Dram armenio'),
(52, 'BB', 'BRB', 1246, 'Barbados', 'América', 'El Caribe', 'BBD', 'Dólar de Barbados'),
(56, 'BE', 'BEL', 32, 'Bélgica', 'Europa', '', 'EUR', 'Euro'),
(60, 'BM', 'BMU', 1441, 'Bermudas', 'América', 'El Caribe', 'BMD', 'Dólar de Bermuda'),
(64, 'BT', 'BTN', 975, 'Bhután', 'Asia', '', 'BTN', 'Ngultrum de Bután'),
(68, 'BO', 'BOL', 591, 'Bolivia', 'América', 'América del Sur', 'BOB', 'Boliviano'),
(70, 'BA', 'BIH', 387, 'Bosnia y Herzegovina', 'Europa', '', 'BAM', 'Marco convertible de Bosnia-Herzegovina'),
(72, 'BW', 'BWA', 267, 'Botsuana', 'África', '', 'BWP', 'Pula de Botsuana'),
(74, 'BV', 'BVT', 0, 'Isla Bouvet', '', '', '', ''),
(76, 'BR', 'BRA', 55, 'Brasil', 'América', 'América del Sur', 'BRL', 'Real brasileño'),
(84, 'BZ', 'BLZ', 501, 'Belice', 'América', 'América Central', 'BZD', 'Dólar de Belice'),
(86, 'IO', 'IOT', 0, 'Territorio Británico del Océano Índico', '', '', '', ''),
(90, 'SB', 'SLB', 677, 'Islas Salomón', 'Oceanía', '', 'SBD', 'Dólar de las Islas Salomón'),
(92, 'VG', 'VGB', 1284, 'Islas Vírgenes Británicas', 'América', 'El Caribe', '', ''),
(96, 'BN', 'BRN', 673, 'Brunéi', 'Asia', '', 'BND', 'Dólar de Brunéi'),
(100, 'BG', 'BGR', 359, 'Bulgaria', 'Europa', '', 'BGN', 'Lev búlgaro'),
(104, 'MM', 'MMR', 95, 'Myanmar', 'Asia', '', 'MMK', 'Kyat birmano'),
(108, 'BI', 'BDI', 257, 'Burundi', 'África', '', 'BIF', 'Franco burundés'),
(112, 'BY', 'BLR', 375, 'Bielorrusia', 'Europa', '', 'BYR', 'Rublo bielorruso'),
(116, 'KH', 'KHM', 855, 'Camboya', 'Asia', '', 'KHR', 'Riel camboyano'),
(120, 'CM', 'CMR', 237, 'Camerún', 'África', '', '', ''),
(124, 'CA', 'CAN', 1, 'Canadá', 'América', 'América del Norte', 'CAD', 'Dólar canadiense'),
(132, 'CV', 'CPV', 238, 'Cabo Verde', 'África', '', 'CVE', 'Escudo caboverdiano'),
(136, 'KY', 'CYM', 1345, 'Islas Caimán', 'América', 'El Caribe', 'KYD', 'Dólar caimano de Islas Caimán'),
(140, 'CF', 'CAF', 236, 'República Centroafricana', 'África', '', '', ''),
(144, 'LK', 'LKA', 94, 'Sri Lanka', 'Asia', '', 'LKR', 'Rupia de Sri Lanka'),
(148, 'TD', 'TCD', 235, 'Chad', 'África', '', '', ''),
(152, 'CL', 'CHL', 56, 'Chile', 'América', 'América del Sur', 'CLP', 'Peso chileno'),
(156, 'CN', 'CHN', 86, 'China', 'Asia', '', 'CNY', 'Yuan Renminbi de China'),
(158, 'TW', 'TWN', 886, 'Taiwán', 'Asia', '', 'TWD', 'Dólar taiwanés'),
(162, 'CX', 'CXR', 61, 'Isla de Navidad', 'Oceanía', '', '', ''),
(166, 'CC', 'CCK', 61, 'Islas Cocos', 'Óceanía', '', '', ''),
(170, 'CO', 'COL', 57, 'Colombia', 'América', 'América del Sur', 'COP', 'Peso colombiano'),
(174, 'KM', 'COM', 269, 'Comoras', 'África', '', 'KMF', 'Franco comoriano de Comoras'),
(175, 'YT', 'MYT', 262, 'Mayotte', 'África', '', '', ''),
(178, 'CG', 'COG', 242, 'Congo', 'África', '', '', ''),
(180, 'CD', 'COD', 243, 'República Democrática del Congo', 'África', '', 'CDF', 'Franco congoleño'),
(184, 'CK', 'COK', 682, 'Islas Cook', 'Oceanía', '', '', ''),
(188, 'CR', 'CRI', 506, 'Costa Rica', 'América', 'América Central', 'CRC', 'Colón costarricense'),
(191, 'HR', 'HRV', 385, 'Croacia', 'Europa', '', 'HRK', 'Kuna croata'),
(192, 'CU', 'CUB', 53, 'Cuba', 'América', 'El Caribe', 'CUP', 'Peso cubano'),
(196, 'CY', 'CYP', 357, 'Chipre', 'Europa', '', 'CYP', 'Libra chipriota'),
(203, 'CZ', 'CZE', 420, 'República Checa', 'Europa', '', 'CZK', 'Koruna checa'),
(204, 'BJ', 'BEN', 229, 'Benín', 'África', '', '', ''),
(208, 'DK', 'DNK', 45, 'Dinamarca', 'Europa', '', 'DKK', 'Corona danesa'),
(212, 'DM', 'DMA', 1767, 'Dominica', 'América', 'El Caribe', '', ''),
(214, 'DO', 'DOM', 1809, 'República Dominicana', 'América', 'El Caribe', 'DOP', 'Peso dominicano'),
(218, 'EC', 'ECU', 593, 'Ecuador', 'América', 'América del Sur', '', ''),
(222, 'SV', 'SLV', 503, 'El Salvador', 'América', 'América Central', 'SVC', 'Colón salvadoreño'),
(226, 'GQ', 'GNQ', 240, 'Guinea Ecuatorial', 'África', '', '', ''),
(231, 'ET', 'ETH', 251, 'Etiopía', 'África', '', 'ETB', 'Birr etíope'),
(232, 'ER', 'ERI', 291, 'Eritrea', 'África', '', 'ERN', 'Nakfa eritreo'),
(233, 'EE', 'EST', 372, 'Estonia', 'Europa', '', 'EEK', 'Corona estonia'),
(234, 'FO', 'FRO', 298, 'Islas Feroe', 'Europa', '', '', ''),
(238, 'FK', 'FLK', 500, 'Islas Malvinas', 'América', 'América del Sur', 'FKP', 'Libra malvinense'),
(239, 'GS', 'SGS', 0, 'Islas Georgias del Sur y Sandwich del Sur', 'América', 'América del Sur', '', ''),
(242, 'FJ', 'FJI', 679, 'Fiyi', 'Oceanía', '', 'FJD', 'Dólar fijiano'),
(246, 'FI', 'FIN', 358, 'Finlandia', 'Europa', '', 'EUR', 'Euro'),
(248, 'AX', 'ALA', 0, 'Islas Gland', 'Europa', '', '', ''),
(250, 'FR', 'FRA', 33, 'Francia', 'Europa', '', 'EUR', 'Euro'),
(254, 'GF', 'GUF', 0, 'Guayana Francesa', 'América', 'América del Sur', '', ''),
(258, 'PF', 'PYF', 689, 'Polinesia Francesa', 'Oceanía', '', '', ''),
(260, 'TF', 'ATF', 0, 'Territorios Australes Franceses', '', '', '', ''),
(262, 'DJ', 'DJI', 253, 'Yibuti', 'África', '', 'DJF', 'Franco yibutiano'),
(266, 'GA', 'GAB', 241, 'Gabón', 'África', '', '', ''),
(268, 'GE', 'GEO', 995, 'Georgia', 'Europa', '', 'GEL', 'Lari georgiano'),
(270, 'GM', 'GMB', 220, 'Gambia', 'África', '', 'GMD', 'Dalasi gambiano'),
(275, 'PS', 'PSE', 0, 'Palestina', 'Asia', '', '', ''),
(276, 'DE', 'DEU', 49, 'Alemania', 'Europa', '', 'EUR', 'Euro'),
(288, 'GH', 'GHA', 233, 'Ghana', 'África', '', 'GHC', 'Cedi ghanés'),
(292, 'GI', 'GIB', 350, 'Gibraltar', 'Europa', '', 'GIP', 'Libra de Gibraltar'),
(296, 'KI', 'KIR', 686, 'Kiribati', 'Oceanía', '', '', ''),
(300, 'GR', 'GRC', 30, 'Grecia', 'Europa', '', 'EUR', 'Euro'),
(304, 'GL', 'GRL', 299, 'Groenlandia', 'América', 'América del Norte', '', ''),
(308, 'GD', 'GRD', 1473, 'Granada', 'América', 'El Caribe', '', ''),
(312, 'GP', 'GLP', 0, 'Guadalupe', 'América', 'El Caribe', '', ''),
(316, 'GU', 'GUM', 1671, 'Guam', 'Oceanía', '', '', ''),
(320, 'GT', 'GTM', 502, 'Guatemala', 'América', 'América Central', 'GTQ', 'Quetzal guatemalteco'),
(324, 'GN', 'GIN', 224, 'Guinea', 'África', '', 'GNF', 'Franco guineano'),
(328, 'GY', 'GUY', 592, 'Guyana', 'América', 'América del Sur', 'GYD', 'Dólar guyanés'),
(332, 'HT', 'HTI', 509, 'Haití', 'América', 'El Caribe', 'HTG', 'Gourde haitiano'),
(334, 'HM', 'HMD', 0, 'Islas Heard y McDonald', 'Oceanía', '', '', ''),
(336, 'VA', 'VAT', 39, 'Ciudad del Vaticano', 'Europa', '', '', ''),
(340, 'HN', 'HND', 504, 'Honduras', 'América', 'América Central', 'HNL', 'Lempira hondureño'),
(344, 'HK', 'HKG', 852, 'Hong Kong', 'Asia', '', 'HKD', 'Dólar de Hong Kong'),
(348, 'HU', 'HUN', 36, 'Hungría', 'Europa', '', 'HUF', 'Forint húngaro'),
(352, 'IS', 'ISL', 354, 'Islandia', 'Europa', '', 'ISK', 'Króna islandesa'),
(356, 'IN', 'IND', 91, 'India', 'Asia', '', 'INR', 'Rupia ind
|
ia'),
(360, 'ID', 'IDN', 62, 'Indonesia', 'Asia', '', 'IDR', 'Rupiah indonesia'),
(364, 'IR', 'IRN', 98, 'Irán', 'Asi
|
a', '', 'IRR', 'Rial iraní'),
(368, 'IQ', 'IRQ', 964, 'Iraq', 'Asia', '', 'IQD', 'Dinar iraquí'),
(372, 'IE', 'IRL', 353, 'Irlanda', 'Europa', '', 'EUR', 'Euro'),
(376, 'IL', 'ISR', 972, 'Israel', 'Asia', '', 'ILS', 'Nuevo
|
genialis/resolwe
|
resolwe/flow/models/collection.py
|
Python
|
apache-2.0
| 3,575
| 0.000559
|
"""Resolwe collection model."""
from django.contrib.postgres.fields import ArrayField
from django.contrib.postgres.indexes import GinIndex
from django.contrib.postgres.search import SearchVectorField
from django.db import models, transaction
from resolwe.permissions.models import PermissionObject, PermissionQuerySet
from .base import BaseModel, BaseQuerySet
from .utils import DirtyError, bulk_duplicate, validate_schema
class BaseCollection(BaseModel):
"""Template for Postgres model for storing a collection."""
class Meta(BaseModel.Meta):
"""BaseCollection Meta options."""
abstract = True
#: detailed description
description = models.TextField(blank=True)
settings = models.JSONField(default=dict)
#: collection descriptor schema
descriptor_schema = models.ForeignKey(
"flow.DescriptorSchema", blank=True, null=True, on_delete=models.PROTECT
)
#: collection descriptor
descriptor = models.JSONField(default=dict)
#: indicate whether `descriptor` doesn't match `descriptor_schema` (is dirty)
descriptor_dirty = models.BooleanField(default=False)
#: tags for categorizing objects
tags = ArrayField(models.CharField(max_length=255), default=list)
#: field used for full-text search
search = SearchVectorField(null=True)
def save(self, *args, **kwargs):
"""Perform descriptor validation and save object."""
if self.descriptor_schema:
try:
validate_schema(self.descriptor, self.descriptor_schema.schema)
self.descriptor_dirty = Fal
|
se
except DirtyError:
self.descriptor_dirty = Tru
|
e
elif self.descriptor and self.descriptor != {}:
raise ValueError(
"`descriptor_schema` must be defined if `descriptor` is given"
)
super().save()
class CollectionQuerySet(BaseQuerySet, PermissionQuerySet):
"""Query set for ``Collection`` objects."""
@transaction.atomic
def duplicate(self, contributor):
"""Duplicate (make a copy) ``Collection`` objects."""
return bulk_duplicate(collections=self, contributor=contributor)
class Collection(BaseCollection, PermissionObject):
"""Postgres model for storing a collection."""
class Meta(BaseCollection.Meta):
"""Collection Meta options."""
permissions = (
("view", "Can view collection"),
("edit", "Can edit collection"),
("share", "Can share collection"),
("owner", "Is owner of the collection"),
)
indexes = [
models.Index(name="idx_collection_name", fields=["name"]),
GinIndex(
name="idx_collection_name_trgm",
fields=["name"],
opclasses=["gin_trgm_ops"],
),
models.Index(name="idx_collection_slug", fields=["slug"]),
GinIndex(name="idx_collection_tags", fields=["tags"]),
GinIndex(name="idx_collection_search", fields=["search"]),
]
#: manager
objects = CollectionQuerySet.as_manager()
#: duplication date and time
duplicated = models.DateTimeField(blank=True, null=True)
def is_duplicate(self):
"""Return True if collection is a duplicate."""
return bool(self.duplicated)
def duplicate(self, contributor):
"""Duplicate (make a copy)."""
return bulk_duplicate(
collections=self._meta.model.objects.filter(pk=self.pk),
contributor=contributor,
)[0]
|
Diti24/python-ivi
|
ivi/lecroy/lecroyWR204MXIA.py
|
Python
|
mit
| 1,653
| 0.001815
|
"""
Python Interchangeable Virtual Instrument Library
Copyright (c) 2012-2016 Alex Forencich
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
from .lecroyWRXIA import *
class lecroyWR204MXIA(lecroyWRXIA):
"Lecroy WaveRunner 204MXi-A IVI oscilloscope
|
driver"
def __init__(self, *args, **kwargs):
self.__dict__.setdefault('_instrument_id', 'WaveRunner 204MXi-A')
super(lecroy104MXiA, self).__init__(*args, **kwargs)
self._analog_channel_count = 4
self._digital_channel_count = 0
self._channel_count = self._analog_channel_count + self._digital_channel_count
self._bandwidth = 1e9
self._init_chan
|
nels()
|
mantarayforensics/mantaray
|
Tools/Python/entropy_mr.py
|
Python
|
gpl-3.0
| 10,303
| 0.028827
|
#!/usr/bin/env python3
#This program calculates the entropy for a file, files in a folder or disk image
#The user sets a reporting threshold
#########################COPYRIGHT INFORMATION############################
#Copyright (C) 2011 [email protected] #
#This program is free software: you can redistribute it and/or modify #
#it under the terms of the GNU General Public License as published by #
#the Free Software Foundation, either version 3 of the License, or #
#(at your option) any later version. #
#
#This program is distributed in the hope that it will be useful, #
#but WITHOUT ANY WARRANTY; without even the implied warranty of #
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
#GNU General Public License for more details. #
#
#You should have received a copy of the GNU General Public License #
#along with this program. If not, see http://www.gnu.org/licenses/. #
#########################COPYRIGHT INFORMATION############################
#import modules
from easygui import *
from get_case_number import *
from get_output_location import *
from select_file_to_process import *
from select_folder_to_process import *
from parted import *
from mmls import *
from mount import *
from mount_ewf import *
from get_ntuser_paths import *
from get_usrclass_paths import *
from get_system_paths import *
from done import *
from unix2dos import *
from check_for_folder import *
from mount_encase_v6_l01 import *
from calculate_md5 import *
import os
import codecs
from os.path import join
import re
import io
import sys
import string
import subprocess
import pickle
import datetime
import base64
### process_folder #######################################################################################
def process_folder(folder_to_process, export_file, outfile):
for root,dirs,files in os.walk(folder_to_process):
for file_name in files:
abs_file_path = os.path.join(root,file_name)
quoted_abs_file_path = '"'+abs_file_path+'"'
file_name_print = file_name.encode('utf-8')
abs_file_path_print = abs_file_path.encode('utf-8')
#clean up printable variables
file_name_print = re.sub('b\'','',str(file_name_print))
file_name_print =
|
re.sub("'",'',file_name_print)
abs_file_path_print = re.sub('b\'','',str(abs_file_path_print))
abs_file_path_print = re.sub("'",'', abs_file_path_print)
#don't process link files
if not (os.path.islink(abs_file_path)):
#get file size
try:
file_size = os.path.getsize(abs_file_path)
except:
print("Could not get filesize for file: " + abs_file_path)
outfile.write("Could not get filesize for file: " + abs_file_path + "\n")
if(file_size)
|
:
try:
ent = calc_entropy(abs_file_path)
print("Filename: " + file_name + "\t" + "Entropy: " + ent)
export_file.write(ent + "," + str(file_name_print) + "," + str(file_size) + "," + str(abs_file_path_print) + "\n")
except:
print("Could not get entropy for file: " + abs_file_path)
outfile.write("Could not get entropy for file: " + str(abs_file_path_print) + "\n")
else:
print("File: " + file_name + " has 0 file size....skipping")
outfile.write("File: " + file_name + "has 0 file size....skipping\n")
else:
print("File: " + file_name + " is link file....skipping")
outfile.write("File: " + file_name + "is link file....skipping\n")
##########################################################################################################
### calc_entropy #########################################################################################
def calc_entropy(file_to_process):
if(re.search("'", file_to_process)):
entropy = subprocess.check_output(['ent ' + '"' + file_to_process + '"' + " | grep Entropy | awk '{print $3}'"], shell=True)
else:
entropy = subprocess.check_output(['ent ' + "'" + file_to_process + "'" + " | grep Entropy | awk '{print $3}'"], shell=True)
entropy = entropy.strip()
entropy_string = entropy.decode(encoding='UTF-8')
return entropy_string
##########################################################################################################
def entropy_mr(item_to_process, case_number, root_folder_path, evidence):
print("The item to process is: " + item_to_process)
print("The case_name is: " + case_number)
print("The output folder is: " + root_folder_path)
print("The evidence to process is: " + evidence)
evidence_no_quotes = evidence
evidence = '"' + evidence + '"'
#get datetime
now = datetime.datetime.now()
#set Mount Point
mount_point = "/mnt/" + "MantaRay_" + now.strftime("%Y-%m-%d_%H_%M_%S_%f")
#create output folder path
folder_path = root_folder_path + "/" + "Entropy"
check_for_folder(folder_path, "NONE")
#open a log file for output
log_file = folder_path + "/Entropy_logfile.txt"
outfile = open(log_file, 'wt+')
#open file to write output
exp_file = folder_path + "/" + case_number +"_entropy.csv"
export_file = open(exp_file, 'a+', encoding='latin-1', errors="ignore")
#export_file = open(exp_file, 'a')
if(item_to_process == "Single File"):
ent = calc_entropy(evidence)
print(ent)
elif(item_to_process == "Directory"):
folder_to_process = evidence_no_quotes
process_folder(folder_to_process, export_file, outfile)
elif(item_to_process =="EnCase Logical Evidence File"):
file_to_process = evidence
mount_point = mount_encase_v6_l01(case_number, file_to_process, outfile)
process_folder(mount_point, export_file, outfile)
#umount
if(os.path.exists(mount_point)):
subprocess.call(['sudo umount -f ' + mount_point], shell=True)
os.rmdir(mount_point)
elif(item_to_process == "Bit-Stream Image"):
Image_Path = evidence
#process every file on every partition
#get datetime
now = datetime.datetime.now()
#set Mount Point
mount_point = "/mnt/" + now.strftime("%Y-%m-%d_%H_%M_%S_%f")
#check if Image file is in Encase format
if re.search(".E01", Image_Path):
#strip out single quotes from the quoted path
#no_quotes_path = Image_Path.replace("'","")
#print("THe no quotes path is: " + no_quotes_path)
#call mount_ewf function
Image_Path = mount_ewf(Image_Path, outfile,mount_point)
#call mmls function
partition_info_dict, temp_time = mmls(outfile, Image_Path)
partition_info_dict_temp = partition_info_dict
#get filesize of mmls_output.txt
file_size = os.path.getsize("/tmp/mmls_output_" + temp_time + ".txt")
#if filesize of mmls output is 0 then run parted
if(file_size == 0):
print("mmls output was empty, running parted")
outfile.write("mmls output was empty, running parted")
#call parted function
partition_info_dict, temp_time = parted(outfile, Image_Path)
else:
#read through the mmls output and look for GUID Partition Tables (used on MACS)
mmls_output_file = open("/tmp/mmls_output_" + temp_time + ".txt", 'r')
for line in mmls_output_file:
if re.search("GUID Partition Table", line):
print("We found a GUID partition table, need to use parted")
outfile.write("We found a GUID partition table, need to use parted\n")
#call parted function
partition_info_dict, temp_time = parted(outfile, Image_Path)
mmls_output_file.close()
#loop through the dictionary containing the partition info (filesystem is VALUE, offset is KEY)
for key,value in sorted(partition_info_dict.items()):
#disable auto-mount in nautilis - this stops a nautilis window from popping up everytime the mount command is executed
cmd_false = "sudo gsettings set org.gnome.desktop.media-handling automount false && sudo gsettings set org.gnome.desktop.media-handling automount-open false"
try:
subprocess.call([cmd_false], shell=True)
except:
print("Autmount false failed")
#call mount sub-routine
success_code, loopback_device_mount = mount(value,str(key),Image_Path, outfile, mount_point)
if(succes
|
apinsard/funtoo-overlay
|
funtoo/scripts/merge-funtoo-staging.py
|
Python
|
gpl-2.0
| 14,296
| 0.020425
|
#!/usr/bin/python3
import os
import sys
from merge_utils import *
xml_out = etree.Element("packages")
funtoo_staging_w = GitTree("funtoo-staging", "master", "repos@localhost:ports/funtoo-staging.git", root="/var/git/dest-trees/funtoo-staging", pull=False, xml_out=xml_out)
#funtoo_staging_w = GitTree("funtoo-staging-unfork", "master", "repos@localhost:ports/funtoo-staging-unfork.git", root="/var/git/dest-trees/funtoo-staging-unfork", pull=False, xml_out=None)
xmlfile="/home/ports/public_html/packages.xml"
nopush=False
funtoo_overlay = GitTree("funtoo-overlay", "master", "repos@localhost:funtoo-overlay.git", pull=True)
# We treat our Gentoo staging overlay specially, so it's listed separately. This overlay contains all Gentoo
# ebuilds, in a git repository. We use a special file in the funtoo-overlay/funtoo/scripts directory (next to
# this file) to provide a SHA1 of the commit of the gentoo-staging overlay that we want to use as a basis
# for our merges. Let's grab the SHA1 hash from that file:
p = os.path.join(funtoo_overlay.root,"funtoo/scripts/commit-staged")
if os.path.exists(p):
a = open(p,"r")
commit = a.readlines()[0].strip()
print("Using commit: %s" % commit)
else:
commit = None
gentoo_staging_r = GitTree("gentoo-staging", "master", "repos@localhost:ports/gentoo-staging.git", commit=commit, pull=True)
# These overlays are monitored for changes -- if there are changes in these overlays, we regenerate the entire
# tree. If there a
|
ren't changes in these overlays, we don't.
shards = {
"perl" : GitTree("gentoo-perl-shard", "1fc10379b04cb4aaa29e824288f3ec22badc6b33", "repos@localhost:gentoo-perl-shard.git", pull=True),
"kde" : GitTree("gentoo-kde-shard", "cd4e1129ddddaa21df367ecd4f68aab894e57b31", "repos@localhost:gentoo-kde-shard.git", pull=True),
"gnome" : GitTree("gentoo-gnome-shard", "ffabb752f8f4e23a865ffe9caf72f950695e2f26", "repos
|
@localhost:ports/gentoo-gnome-shard.git", pull=True),
"x11" : GitTree("gentoo-x11-shard", "12c1bdf9a9bfd28f48d66bccb107c17b5f5af577", "repos@localhost:ports/gentoo-x11-shard.git", pull=True),
"office" : GitTree("gentoo-office-shard", "9a702057d23e7fa277e9626344671a82ce59442f", "repos@localhost:ports/gentoo-office-shard.git", pull=True),
"core" : GitTree("gentoo-core-shard", "56e5b9edff7dc27e828b71010d019dcbd8e176fd", "repos@localhost:gentoo-core-shard.git", pull=True)
}
# perl: 1fc10379b04cb4aaa29e824288f3ec22badc6b33 (Updated 6 Dec 2016)
# kde: cd4e1129ddddaa21df367ecd4f68aab894e57b31 (Updated 25 Dec 2016)
# gnome: ffabb752f8f4e23a865ffe9caf72f950695e2f26 (Updated 20 Sep 2016)
# x11: 12c1bdf9a9bfd28f48d66bccb107c17b5f5af577 (Updated 24 Dec 2016)
# office: 9a702057d23e7fa277e9626344671a82ce59442f (Updated 29 Nov 2016)
# core: 56e5b9edff7dc27e828b71010d019dcbd8e176fd (Updated 17 Dec 2016)
# funtoo-toolchain: b97787318b7ffcfeaacde82cd21ddd5e207ad1f4 (Updated 25 Dec 2016)
funtoo_overlays = {
"funtoo_media" : GitTree("funtoo-media", "master", "repos@localhost:funtoo-media.git", pull=True),
"plex_overlay" : GitTree("funtoo-plex", "master", "https://github.com/Ghent/funtoo-plex.git", pull=True),
#"gnome_fixups" : GitTree("gnome-3.16-fixups", "master", "repos@localhost:ports/gnome-3.16-fixups.git", pull=True),
"gnome_fixups" : GitTree("gnome-3.20-fixups", "master", "repos@localhost:ports/gnome-3.20-fixups.git", pull=True),
"funtoo_toolchain" : GitTree("funtoo-toolchain", "b97787318b7ffcfeaacde82cd21ddd5e207ad1f4", "repos@localhost:funtoo-toolchain-overlay.git", pull=True),
"ldap_overlay" : GitTree("funtoo-ldap", "master", "repos@localhost:funtoo-ldap-overlay.git", pull=True),
"deadbeef_overlay" : GitTree("deadbeef-overlay", "master", "https://github.com/damex/deadbeef-overlay.git", pull=True),
"gambas_overlay" : GitTree("gambas-overlay", "master", "https://github.com/damex/gambas-overlay.git", pull=True),
"wmfs_overlay" : GitTree("wmfs-overlay", "master", "https://github.com/damex/wmfs-overlay.git", pull=True),
"flora" : GitTree("flora", "master", "repos@localhost:flora.git", pull=True),
}
# These are other overlays that we merge into the Funtoo tree. However, we just pull in the most recent versions
# of these when we regenerate our tree.
other_overlays = {
"foo_overlay" : GitTree("foo-overlay", "master", "https://github.com/slashbeast/foo-overlay.git", pull=True),
"bar_overlay" : GitTree("bar-overlay", "master", "git://github.com/adessemond/bar-overlay.git", pull=True),
"squeezebox_overlay" : GitTree("squeezebox", "master", "git://anongit.gentoo.org/user/squeezebox.git", pull=True),
"pantheon_overlay" : GitTree("pantheon", "master", "https://github.com/pimvullers/elementary.git", pull=True),
"pinsard_overlay" : GitTree("pinsard", "master", "https://github.com/apinsard/sapher-overlay.git", pull=True),
"sabayon_for_gentoo" : GitTree("sabayon-for-gentoo", "master", "git://github.com/Sabayon/for-gentoo.git", pull=True),
"tripsix_overlay" : GitTree("tripsix", "master", "https://github.com/666threesixes666/tripsix.git", pull=True),
"faustoo_overlay" : GitTree("faustoo", "master", "https://github.com/fmoro/faustoo.git", pull=True),
"wltjr_overlay" : GitTree("wltjr", "master", "https://github.com/Obsidian-StudiosInc/os-xtoo", pull=True),
"vmware_overlay" : GitTree("vmware", "master", "git://anongit.gentoo.org/proj/vmware.git", pull=True)
}
funtoo_changes = False
if funtoo_overlay.changes:
funtoo_changes = True
elif gentoo_staging_r.changes:
funtoo_changes = True
else:
for fo in funtoo_overlays:
if funtoo_overlays[fo].changes:
funtoo_changes = True
break
# This next code regenerates the contents of the funtoo-staging tree. Funtoo's tree is itself composed of
# many different overlays which are merged in an automated fashion. This code does it all.
pull = True
if nopush:
push = False
else:
push = "master"
# base_steps define the initial steps that prepare our destination tree for writing. Checking out the correct
# branch, copying almost the full entirety of Gentoo's portage tree to our destination tree, and copying over
# funtoo overlay licenses, metadata, and also copying over GLSA's.
base_steps = [
GitCheckout("master"),
SyncFromTree(gentoo_staging_r, exclude=[
"/metadata/cache/**",
"ChangeLog",
"dev-util/metro",
"skel.ChangeLog",
]),
]
# Steps related to generating system profiles. These can be quite order-dependent and should be handled carefully.
# Generally, the funtoo_overlay sync should be first, then the gentoo_staging_r SyncFiles, which overwrites some stub
# files in the funtoo overlay.
profile_steps = [
SyncDir(funtoo_overlay.root, "profiles", "profiles", exclude=["categories", "updates"]),
CopyAndRename("profiles/funtoo/1.0/linux-gnu/arch/x86-64bit/subarch", "profiles/funtoo/1.0/linux-gnu/arch/pure64/subarch", lambda x: os.path.basename(x) + "-pure64"),
SyncFiles(gentoo_staging_r.root, {
"profiles/package.mask":"profiles/package.mask/00-gentoo",
"profiles/arch/amd64/package.use.mask":"profiles/funtoo/1.0/linux-gnu/arch/x86-64bit/package.use.mask/01-gentoo",
"profiles/features/multilib/package.use.mask":"profiles/funtoo/1.0/linux-gnu/arch/x86-64bit/package.use.mask/02-gentoo",
"profiles/arch/amd64/use.mask":"profiles/funtoo/1.0/linux-gnu/arch/x86-64bit/use.mask/01-gentoo",
"profiles/arch/x86/package.use.mask":"profiles/funtoo/1.0/linux-gnu/arch/x86-32bit/package.use.mask/01-gentoo",
"profiles/arch/x86/use.mask":"profiles/funtoo/1.0/linux-gnu/arch/x86-32bit/use.mask/01-gentoo",
"profiles/default/linux/package.use.mask":"profiles/funtoo/1.0/linux-gnu/package.use.mask/01-gentoo",
"profiles/default/linux/use.mask":"profiles/funtoo/1.0/linux-gnu/use.mask/01-gentoo",
"profiles/arch/amd64/no-multilib/package.use.mask":"profiles/funtoo/1.0/linux-gnu/arch/pure64/package.use.mask/01-gentoo",
"profiles/arch/amd64/no-multilib/package.mask":"profiles/funtoo/1.0/linux-gnu/arch/pure64/package.mask/01-gentoo",
"profiles/arch/amd64/no-multilib/use.mask":"profiles/funtoo/1.0/linux-gnu/arch/pure64/use.mask/01-gentoo"
}),
SyncFiles(funtoo_overlays["deadbeef_overlay"].root, {
"profiles/package.mask":"profiles/package.mask/deadbeef-mask"
}),
SyncFiles(funtoo_overlays["wmfs_overlay"].root,
|
yusufshakeel/Python-Project
|
example/expo.py
|
Python
|
mit
| 55
| 0.036364
|
#exponent
#
|
find
|
2^n
n = input("Enter n: ")
print 2**n
|
lzjever/pullot
|
pullot/framebuffer.py
|
Python
|
mit
| 2,966
| 0.020566
|
# -*- coding: utf-8 -*-
# The MIT License (MIT)
# Copyright (c) 2015 Percy Li
# See LICENSE for details.
import struct
import threading
import copy
class FrameBuffer(object):
def __init__(self,decoder = None):
self.data_buffer = bytes([])
self.decoder = decoder
def set_decoder (self,decoder = None):
self.decoder = decoder
def pop_frame (self):
if self.decoder is not None:
fe,df = self.decoder(self.data_buffer)
self.data_buffer = self.data_buffer[fe:]
if df:
#logger.ods ('Decoded frame : \n ' + str(df) ,lv='dev',cat = 'foundation.tcp')
pass
return df # None if fail
else:
# if no decoder was specified , return a single byte in the head of the buffer.
return self.pop_buffer()
def push_frame (self,frame):
if hasattr(frame,'marshal'):
self.data_buffer += frame.marshal()
return
if isinstance(frame,bytes):
self.data_buffer += frame
return
def append_buffer (self,buf):
self.data_buffer += buf
def pop_buffer (self):
if self.get_buffer_length() == 0:
return None
_head = self.data_buffer[0]
self.data_buffer = self.data_buffer[1:]
return _head
def get_buffer (self):
return self.data_buffer
def clear_buffer (self):
self.data_buffer = bytes([])
def get_buffer_length(self):
return len(self.data_buffer)
# thread safe version
class TSFrameBuffer(FrameBuffer):
def __init__(self,decoder = None):
FrameBuffer.__init__(self,decoder)
self.internal_lock = threading.RLock()
def set_decoder (self,decoder = None):
with self.internal_lock:
return FrameBuffer.set_decoder(self,decoder)
def pop_frame (self):
with self.internal_lock:
return FrameBuffer.pop_frame(self)
def push_frame (self,frame):
with self.internal_lock:
return FrameBuffer.push_frame(self,frame)
def append_buffer (self,buf):
with self.internal_lock:
|
return FrameBuffer.append_buffer(self,buf)
def pop_buf
|
fer (self):
with self.internal_lock:
return FrameBuffer.pop_buffer(self)
def get_buffer (self):
with self.internal_lock:
return copy.deepcopy( FrameBuffer.get_buffer(self) )
def clear_buffer (self):
with self.internal_lock:
return FrameBuffer.clear_buffer(self)
def get_buffer_length(self):
with self.internal_lock:
return FrameBuffer.get_buffer_length(self)
if __name__ == '__main__':
fb = FrameBuffer()
|
fredreichbier/babbisch-ooc
|
babbisch_ooc/wraplib/utils.py
|
Python
|
mit
| 279
| 0.007168
|
import re
def pythonize_camelcase_name(name):
"""
GetProperty -> get_property
"""
de
|
f repl(match):
return '_' + match.group(0).lower()
s = re.sub(r'([A-Z])'
|
, repl, name)
if s.startswith('_'):
return s[1:]
else:
return s
|
jr55662003/My_Rosalind_solution
|
ProteinMass/PRTM.py
|
Python
|
gpl-3.0
| 450
| 0.026667
|
'''
Given: A protein string PP of length at most 100
|
0 aa.
Return: The total weight of PP. Consult the monoisotopic mass table.
'''
def weight(protein):
# Build mass table from mass_table.txt
mass = {}
with open("mass_table.txt", "r") as m:
for line in m:
lst = line.split(" ")
mass[lst[0]] = floa
|
t(lst[1].rstrip())
# Calculate the mass of protein
total = 0
for aa in protein:
total += mass[aa]
return total
|
mipt-cs-on-python3/arithmetic_dragons
|
tournament.py
|
Python
|
gpl-3.0
| 1,950
| 0.004271
|
# coding: utf-8
# license: GPLv3
from enemies import *
from hero import *
def annoying_input_int(message =''):
answer = None
while answer == None:
try:
answer = int(input(message))
except ValueError:
print('Вы ввели недопустимые символы')
return answer
def game_tournament(hero, dragon_list):
for dragon in dragon_list:
print('Вышел', dragon._color,
|
'дракон!')
while dragon.is_alive() and hero.is_alive():
print('Вопрос:', dragon.question())
answer = annoying_input_int('Ответ:')
if dragon.check_answer(answer):
hero.attack(dragon)
|
print('Верно! \n** дракон кричит от боли **')
else:
dragon.attack(hero)
print('Ошибка! \n** вам нанесён удар... **')
if dragon.is_alive():
break
print('Дракон', dragon._color, 'повержен!\n')
if hero.is_alive():
print('Поздравляем! Вы победили!')
print('Ваш накопленный опыт:', hero._experience)
else:
print('К сожалению, Вы проиграли...')
def start_game():
try:
print('Добро пожаловать в арифметико-ролевую игру с драконами!')
print('Представьтесь, пожалуйста: ', end = '')
hero = Hero(input())
dragon_number = 3
dragon_list = generate_dragon_list(dragon_number)
assert(len(dragon_list) == 3)
print('У Вас на пути', dragon_number, 'драконов!')
game_tournament(hero, dragon_list)
except EOFError:
print('Поток ввода закончился. Извините, принимать ответы более невозможно.')
|
ukch/online_sabacc
|
src/sabacc/api/viewhelpers.py
|
Python
|
gpl-3.0
| 494
| 0
|
f
|
rom django.core.urlresolvers import reverse
import django.http
import django.utils.simplejson as json
import functools
def make_url(request, reversible):
return request.build_absolute_uri(reverse(reversible))
def json_output(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
output = func(*args, **kwargs)
return django.
|
http.HttpResponse(json.dumps(output),
content_type="application/json")
return wrapper
|
pakodekker/oceansar
|
oceansar/ocs_io/processed.py
|
Python
|
gpl-3.0
| 3,344
| 0.000299
|
import time
from netCDF4 import Dataset
from oceansar.ocs_io import NETCDFHandler
class ProcFile(NETCDFHandler):
""" Processed raw data file generated by the OASIS Simulator
:param file_name: File name
:param mode: Access mode (w = write, r = read, r+ = read + append)
:param proc_dim: Processed raw data dimensions
:param format: netCDF format
.. note::
Refer to netCDF4 Python library for details on access mode and
available formats
"""
def __init__(self, file_name, mode, proc_dim=None, format='NETCDF4'):
self.__file__ = Dataset(file_name, mode, format)
# If writing, define file
if mode == 'w':
# Set file attributes
self.__file__.description = 'OCEANSAR Processed SLC Data File'
self.__file__.history = 'Created ' + time.ctime(time.time())
self.__file__.source = 'OCEANSAR Simulator'
# Dimensions
if not proc_dim:
raise ValueError('Processed raw
|
data dime
|
nsions are needed when creating a new file!')
self.__file__.createDimension('ch_dim', proc_dim[0])
self.__file__.createDimension('pol_dim', proc_dim[1])
self.__file__.createDimension('az_dim', proc_dim[2])
self.__file__.createDimension('rg_dim', proc_dim[3])
num_ch = self.__file__.createVariable('num_ch', 'i4')
# Variables
slc_r = self.__file__.createVariable('slc_r',
'f8',
('ch_dim',
'pol_dim',
'az_dim',
'rg_dim'))
slc_i = self.__file__.createVariable('slc_i',
'f8',
('ch_dim',
'pol_dim',
'az_dim',
'rg_dim'))
slc_r.units = '[]'
slc_i.units = '[]'
inc_angle = self.__file__.createVariable('inc_angle', 'f8')
inc_angle.units = '[deg]'
f0 = self.__file__.createVariable('f0', 'f8')
f0.units = '[Hz]'
ant_L = self.__file__.createVariable('ant_L', 'f8')
ant_L.units = '[m]'
prf = self.__file__.createVariable('prf', 'f8')
prf.units = '[Hz]'
v_ground = self.__file__.createVariable('v_ground', 'f8')
v_ground.units = '[m/s]'
orbit_alt = self.__file__.createVariable('orbit_alt', 'f8')
orbit_alt.units = '[m]'
sr0 = self.__file__.createVariable('sr0', 'f8')
sr0.units = '[m]'
rg_sampling = self.__file__.createVariable('rg_sampling', 'f8')
rg_sampling.units = '[Hz]'
rg_bw = self.__file__.createVariable('rg_bw', 'f8')
rg_bw.units = '[Hz]'
b_ati = self.__file__.createVariable('b_ati', 'f8', 'ch_dim')
b_ati.units = '[m]'
b_xti = self.__file__.createVariable('b_xti', 'f8', 'ch_dim')
b_xti.units = '[m]'
|
robertostling/bnas
|
bnas/regularize.py
|
Python
|
gpl-3.0
| 1,950
| 0.002564
|
"""Regularizations.
Each regularization method is implemented as a subclass of
:class:`Regularizer`,
where the constructor takes the hyperparameters, and the `__call__` method
constructs the symbolic loss expression given a parameter.
These are made for use with :meth:`Model.regularize`, but can also be used
directly in the :meth:`loss` method of :class:`.Model` subclasses.
"""
import theano
import theano.tensor as T
from theano.ifelse import ifelse
class Regularizer: pass
class L2(Regularizer):
"""L2 loss."""
def __init__(self, penalty=0.01):
self.penalty = penalty
def __call__(self, p):
return T.sqrt(T.sqr(p).sum()) * T.as_tensor_variable(self.penalty)
class StateNorm(Regularizer):
"""Squared norm difference between recurrent states.
Note that this method seems to be unstable if the initial hidden state is
initialized to zero.
David Krueger & Roland Memisevic (2016).
`Regularizing RNNs by stabilizing activations. <http://a
|
rxiv.org/pdf/1511.08400v7.pdf>`_
"""
def __init__(self, penalty=50.0):
self.penalty = penalty
def __call
|
__(self, p, p_mask):
"""Compute the squared norm difference of a sequence.
Example
-------
>>> def loss(self, outputs, outputs_mask):
... # loss() definition from a custom Model subclass
... loss = super().loss()
... pred_states, pred_symbols = self(outputs, outputs_mask)
... # Include transition from initial state
... pred_states = T.concatenate([initial_state, pred_states],
... axis=0)
... return loss + StateNorm(50.0)(pred_states, outputs_mask)
"""
mask = p_mask[:-1]
l2 = T.sqrt(T.sqr(p).sum(axis=2))
diff = (l2[1:] - l2[:-1]) * mask
return (self.penalty * T.sqr(diff).sum() /
mask.sum().astype(theano.config.floatX))
|
cpcloud/PyTables
|
mswindows/get_pytables_version.py
|
Python
|
bsd-3-clause
| 300
| 0.003333
|
# Print the version splitted in three components
import sys
verfile = sys.argv[1]
f = open(verfile)
version = f.read()
l = [a[0] for a in version.split('.') if a[0] in '0123456789']
# If
|
no revision, '0' is added
if len(l) == 2:
l.append('0')
for i in l:
print i,
f.close
|
()
|
Karel-van-de-Plassche/bokeh
|
bokeh/io/notebook.py
|
Python
|
bsd-3-clause
| 18,064
| 0.005314
|
#-----------------------------------------------------------------------------
# Copyright (c) 2012 - 2017, Anaconda, Inc. All rights reserved.
#
# Powered by the Bokeh Development Team.
#
# The full license is in the file LICENSE.txt, distributed with this software.
#-----------------------------------------------------------------------------
'''
'''
#-----------------------------------------------------------------------------
# Boilerplate
#-----------------------------------------------------------------------------
from __future__ import absolute_import, division, print_function, unicode_literals
import logging
log = logging.getLogger(__name__)
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
# Standard library imports
import json
from warnings import warn
from uuid import uuid4
# External imports
# Bokeh imports
from .state import curstate
from ..util.serialization import make_id
#-----------------------------------------------------------------------------
# Globals and constants
#-----------------------------------------------------------------------------
HTML_MIME_TYPE = 'text/html'
JS_MIME_TYPE = 'application/javascript'
LOAD_MIME_TYPE = 'application/vnd.bokehjs_load.v0+json'
EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json'
#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------
class CommsHandle(object):
'''
'''
_json = {}
def __init__(self, comms, cell_doc):
self._cellno = None
try:
from IPython import get_ipython
ip = get_ipython()
hm = ip.history_manager
p_prompt = list(hm.get_tail(1, include_latest=True))[0][1]
self._cellno = p_prompt
except Exception as e:
log.debug("Could not get Notebook cell number, reason: %s", e)
self._comms = comms
self._doc = cell_doc
# Our internal copy of the doc is in perpetual "hold". Events from the
# originating doc will be triggered and collected it it. Events are
# processed/cleared when push_notebook is called for this comms handle
self._doc.hold()
def _repr_html_(self):
if self._cellno is not None:
return "<p><code><Bokeh Notebook handle for <strong>In[%s]</strong>></code></p>" % str(self._cellno)
else:
return "<p><code><Bokeh Notebook handle></code></p>"
@property
def comms(self):
return self._comms
@property
|
def doc(self
|
):
return self._doc
# Adding this method makes curdoc dispatch to this Comms to handle
# and Document model changed events. If we find that the event is
# for a model in our internal copy of the docs, then trigger the
# internal doc with the event so that it is collected (until a
# call to push_notebook processes and clear colleted events)
def _document_model_changed(self, event):
if event.model._id in self.doc._all_models:
self.doc._trigger_on_change(event)
def install_notebook_hook(notebook_type, load, show_doc, show_app, overwrite=False):
''' Install a new notebook display hook.
Bokeh comes with support for Jupyter notebooks built-in. However, there are
other kinds of notebooks in use by different communities. This function
provides a mechanism for other projects to instruct Bokeh how to display
content in other notebooks.
This function is primarily of use to developers wishing to integrate Bokeh
with new notebook types.
Args:
notebook_type (str) :
A name for the notebook type, e.e. ``'Jupyter'`` or ``'Zeppelin'``
If the name has previously been installed, a ``RuntimeError`` will
be raised, unless ``overwrite=True``
load (callable) :
A function for loading BokehJS in a notebook type. The function
will be called with the following arguments:
.. code-block:: python
load(
resources, # A Resources object for how to load BokehJS
verbose, # Whether to display verbose loading banner
hide_banner, # Whether to hide the output banner entirely
load_timeout # Time after which to report a load fail error
)
show_doc (callable) :
A function for displaying Bokeh standalone documents in the
notebook type. This function will be called with the following
arguments:
.. code-block:: python
show_doc(
obj, # the Bokeh object to display
state, # current bokeh.io "state"
notebook_handle # whether a notebook handle was requested
)
If the notebook platform is capable of supporting in-place updates
to plots then this function may return an opaque notebook handle
that can be used for that purpose. The handle will be returned by
``show()``, and can be used by as appropriate to update plots, etc.
by additional functions in the library that installed the hooks.
show_app (callable) :
A function for displaying Bokeh applications in the notebook
type. This function will be called with the following arguments:
.. code-block:: python
show_app(
app, # the Bokeh Application to display
state, # current bokeh.io "state"
notebook_url # URL to the current active notebook page
)
overwrite (bool, optional) :
Whether to allow an existing hook to be overwritten by a new
definition (default: False)
Returns:
None
Raises:
RuntimeError
If ``notebook_type`` is already installed and ``overwrite=False``
'''
if notebook_type in _HOOKS and not overwrite:
raise RuntimeError("hook for notebook type %r already exists" % notebook_type)
_HOOKS[notebook_type] = dict(load=load, doc=show_doc, app=show_app)
def push_notebook(document=None, state=None, handle=None):
''' Update Bokeh plots in a Jupyter notebook output cells with new data
or property values.
When working the the notebook, the ``show`` function can be passed the
argument ``notebook_handle=True``, which will cause it to return a
handle object that can be used to update the Bokeh output later. When
``push_notebook`` is called, any property updates (e.g. plot titles or
data source values, etc.) since the last call to ``push_notebook`` or
the original ``show`` call are applied to the Bokeh output in the
previously rendered Jupyter output cell.
Several example notebooks can be found in the GitHub repository in
the :bokeh-tree:`examples/howto/notebook_comms` directory.
Args:
document (Document, optional) :
A :class:`~bokeh.document.Document` to push from. If None,
uses ``curdoc()``. (default: None)
state (State, optional) :
A :class:`State` object. If None, then the current default
state (set by ``output_file``, etc.) is used. (default: None)
Returns:
None
Examples:
Typical usage is typically similar to this:
.. code-block:: python
from bokeh.plotting import figure
from bokeh.io import output_notebook, push_notebook, show
output_notebook()
plot = figure()
plot.circle([1,2,3], [4,6,5])
handle = show(plot, notebook_handle=True)
# Update the plot title in the earlier cell
plot.title.text = "New Title"
push_notebook(handle=handle)
'''
from ..protocol import Protocol
if state is None:
state = curstate()
if not document:
|
ankitsejwal/Lyndor
|
run.py
|
Python
|
mit
| 6,128
| 0.006538
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
''' Lyndor runs from here - contains the main functions '''
import sys, time, os
import module.message as message
import module.save as save
import module.cookies as cookies
import module.read as read
import install
import module.move as move
import module.draw as draw
import module.rename as rename
import module.exercise_file as exercise_file
from colorama import Fore, init
def main():
''' Main function '''
init()
message.animate_characters(Fore.LIGHTYELLOW_EX, draw.ROCKET, 0.02)
message.spinning_cursor()
message.print_line('\r1. Paste course url or\n' +
'2. Press enter for Bulk Download')
url = input()
print('')
start_time = time.time() #start time counter begins
if url == "":
# If user press Enter (i.e. url empty), get urls from Bulkdownload.txt
urls = read.bulk_download()
if not urls:
sys.exit(message.colored_message(Fore.LIGHTRED_EX, 'Please paste urls in Bulk Download.txt\n'))
for url in urls:
schedule_download(url)
else:
# begin regular download
schedule_download(url)
try:
end_time = time.time()
message.animate_characters(Fore.LIGHTGREEN_EX, draw.COW, 0.02)
message.colored_message(Fore.LIGHTGREEN_EX, "\nThe whole process took {}\n".format(move.hms_string(end_time - start_time)))
except KeyboardInterrupt:
sys.exit(message.colored_message(Fore.LIGHTRED_EX, "\n- Program Interrupted!!\n"))
def schedule_download(url):
''' Look for the scheduled time in settings.json '''
if not read.aria2_installed:
tip = '☝🏻 Tip: Install aria2c for faster downloads, read README.md to learn more.'
message.carriage_return_animate(tip)
if read.download_time == '':
# If download time not set, begin download
download_course(url)
return
else:
counter = True
message.colored_message(Fore.LIGHTGREEN_EX, 'Download time set to: ' + read.download_time + '\
in settings.json, you can change or remove this time in settings.json\n')
try:
while counter:
if time.strftime("
|
%H:%M") == read.download_time:
download_course(url)
return
print(f'Download will start at: {read.download_time} leave this window open.')
time.sleep
|
(60)
except KeyboardInterrupt:
sys.exit(message.colored_message(Fore.LIGHTRED_EX, "\n- Program Interrupted!!\n"))
def download_course(url):
''' download course '''
# Check for a valid url
if url.find('.html') == -1:
sys.exit(message.animate_characters(Fore.LIGHTRED_EX, draw.ANONYMOUS, 0.02))
url = url[:url.find(".html")+5] #strip any extra text after .html in the url
# Folder/File paths
lynda_folder_path = read.location + '/'
course_folder_path = save.course_path(url, lynda_folder_path)
desktop_folder_path = install.get_path("Desktop")
download_folder_path = install.get_path("Downloads")
# Read preferences
use_cookie_for_download = read.course_download_pref
if use_cookie_for_download in ['cookies', 'cookie'] or read.exfile_download_method == 'aria2':
cookie_path = cookies.find_cookie(desktop_folder_path, download_folder_path)
downloading_from_cookie = message.return_colored_message(Fore.LIGHTBLUE_EX, '🍪 Downloading videos using cookies.txt')
message.carriage_return_animate(downloading_from_cookie)
else:
cookie_path = ''
usr_pass_message = message.return_colored_message(Fore.LIGHTGREEN_EX, '⛺ Using username and password combination for download\n')
message.carriage_return_animate(usr_pass_message)
try:
# main operations ->
save.course(url, lynda_folder_path) # Create course folder
save.info_file(url, course_folder_path) # Gather information
save.chapters(url, course_folder_path) # Create chapter folders
save.contentmd(url) # Create content.md
save.videos(url, cookie_path, course_folder_path) # Download videos
rename.videos(course_folder_path) # rename videos
rename.subtitles(course_folder_path) # rename subtitles
move.vid_srt_to_chapter(url, course_folder_path) # Move videos and subtitles to chapter folders
# Download exercise files
if save.check_exercise_file(url):
print('\nExercise file is available to download')
if not read.download_exercise_file:
# if user do not want to download ex-file
print("settings.json says you do not want to download ex-file -> 'download_exercise_file': false")
else:
# if user wants to download ex-file
if read.course_download_pref == 'regular-login':
exercise_file.download(url, course_folder_path, cookie_path)
elif read.exfile_download_pref == 'library-login':
if read.card_number == '':
print('\nTo download ex-file via library login -> Please save library card details in settings.json')
else:
exercise_file.download(url, course_folder_path, cookie_path)
else:
print('\nThe exercise file can only be downloaded through one of the below combinations:')
print('~ Regular login: username + password or')
print('~ Library login: card number, pin and org. url\n')
else: # if exercise file not present
print('This course does not include Exercise files.')
except KeyboardInterrupt:
sys.exit(message.colored_message(Fore.LIGHTRED_EX, "\n- Program Interrupted!!\n"))
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
sys.exit(message.colored_message(Fore.LIGHTRED_EX, "\n- Program Interrupted!!\n"))
|
ufaks/website-addons
|
website_sale_available/__openerp__.py
|
Python
|
lgpl-3.0
| 501
| 0
|
{
'name': "Sale only available products on Website",
'summary': """Sale only availabl
|
e products on Website""",
'version': '1.0.0',
'author': 'IT-Projects LLC, Ivan Yelizariev',
'license': 'GPL-3',
'category': 'Custom',
'website': 'https://yelizariev.github.io',
'images': ['images/available.png'],
'price': 9.00,
'currency':
|
'EUR',
'depends': ['website_sale'],
'data': [
'website_sale_available_views.xml',
],
'installable': True,
}
|
Sbalbp/DIRAC
|
ResourceStatusSystem/Policy/JobRunningWaitingRatioPolicy.py
|
Python
|
gpl-3.0
| 2,447
| 0.042092
|
""" JobRunningWaitingRatioPolicy
Policy that calculates the efficiency following the formula:
( running ) / ( running + waiting + staging )
if the denominator is smaller than 10, it does not take any decision.
"""
from DIRAC import S_OK
from DIRAC.ResourceStatusSystem.PolicySystem.PolicyBase import PolicyBase
__RCSID__ = '$Id: JobRunningWaitingRatioPolicy.py 60769 2013-01-18 11:50:36Z ubeda $'
class JobRunningWaitingRatioPolicy( PolicyBase ):
"""
The JobRunningWaitingRatioPolicy class is a policy that checks the efficiency of the
jobs according to what is on JobDB.
Evaluates the JobRunningWaitingRatioPolicy results given by the JobCommand.JobCommand
"""
@staticmethod
def _evaluate( commandResult ):
""" _evaluate
efficiency < 0.5 :: Banned
efficiency < 0.9 :: Degraded
"""
result = {
'Status' : None,
'Reason' : None
}
if not commandResult[ 'OK' ]:
result[ 'Status' ] = 'Error'
result[ 'Reason' ] = commandResult[ 'Message' ]
return S_OK( result )
commandResult = commandResult[ 'Value' ]
if not commandResult:
result[ 'Status' ] = 'Unknown'
result[ 'Reason' ] = 'No values to
|
take a decision'
return S_OK( result )
commandResult = commandResult[ 0 ]
if not commandResult:
result[ 'Status' ] = 'Unknown'
result[ 'Reason' ] = 'No values to take a decision'
return S_OK( result )
running = float( commandResult[ 'Running' ] )
waiting = float( commandResult[ 'Waiting' ] )
staging = float( commandResult[ 'Staging' ] )
total = running + waiting + staging
#we want
|
a minimum amount of jobs to take a decision ( at least 10 pilots )
if total < 10:
result[ 'Status' ] = 'Unknown'
result[ 'Reason' ] = 'Not enough jobs to take a decision'
return S_OK( result )
efficiency = running / total
if efficiency < 0.4:
result[ 'Status' ] = 'Banned'
elif efficiency < 0.65:
result[ 'Status' ] = 'Degraded'
else:
result[ 'Status' ] = 'Active'
result[ 'Reason' ] = 'Job Running / Waiting ratio of %.2f' % efficiency
return S_OK( result )
#...............................................................................
#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF#EOF
|
vlegoff/tsunami
|
src/test/boostrap/salle/etendue/complexe.py
|
Python
|
bsd-3-clause
| 772
| 0
|
complexe = importeur.salle.creer_etendue("complexe")
complexe.origine = (20, 20)
obstacle = importeur.salle.obstacles["falaise"]
coords = [
(20, 20),
(21, 20),
(22, 20),
(23, 20),
(24, 20),
(25, 20),
(20, 21),
(20, 22),
(20, 23),
(20, 24),
(20, 25),
(19, 25),
(19, 26),
(18, 26),
(17, 26),
(19, 27),
(17, 27),
(17, 28),
(18, 28),
(19, 28),
(20
|
, 28),
(21, 28),
(22, 28),
(23, 28),
(24, 28),
(24, 27),
(24, 26),
(23, 26),
(23, 25),
(23, 24),
(24, 24),
(25, 24),
(25, 23),
(23, 23),
(25, 22),
(22, 22),
(23, 22),
(25, 21),
]
for coord in coords:
complexe.ajouter_obstacle(coord, obsta
|
cle)
complexe.trouver_contour()
|
lhupfeldt/jenkinsflow
|
demo/jobs/hide_password_jobs.py
|
Python
|
bsd-3-clause
| 545
| 0.00367
|
# Copyright (c) 2012 - 2015 Lars Hupfeldt Nielsen, Hupfeldt IT
# All rights reserved. This work is under a BSD license, see LICENSE.TXT.
f
|
rom framework import api_select
def create_jobs(api_type):
api = api_select.api(__file__, api_type)
api.flow_job()
api.job('passwd_args', exec_time=0.5, max_fai
|
ls=0, expect_invocations=1, expect_order=1,
params=(('s1', 'no-secret', 'desc'), ('passwd', 'p2', 'desc'), ('PASS', 'p3', 'desc')))
return api
if __name__ == '__main__':
create_jobs(api_select.ApiType.JENKINS)
|
anhstudios/swganh
|
data/scripts/templates/object/installation/faction_perk/turret/shared_block_sm.py
|
Python
|
mit
| 460
| 0.047826
|
#### NOTICE: THIS FILE IS AUTOG
|
ENERATED
#### MODIFICATIONS MAY BE LOST IF DONE IMPROPERLY
#### PLEASE SEE THE ONLINE DOCUMENTATION FOR EXAMPLES
from swgpy.object import *
def create(kernel):
result = Installation()
result.template = "object/installation/faction_perk/turret/shared_block_sm.iff"
result.attribute_template_id = -1
result.stfName("turret_n","block_small")
#### BEGIN
|
MODIFICATIONS ####
#### END MODIFICATIONS ####
return result
|
dimitrius-brest/katalog-poseleniy-RP
|
converter-vkwiki2md/convert2md.py
|
Python
|
cc0-1.0
| 3,623
| 0.019257
|
# -*- coding: utf-8 -*-
try:
f1 = open("input.txt","r",encoding="utf-8")
except IOError:
print("Не удалось найти входной файл input.txt")
try:
f2 = open("output.txt","w",encoding="utf-8")
except IOError:
print("Не удалось открыть выходной файл output.txt")
import re # импортируем модуль работы с регулярными выражениями
# --- регулярное выражение для заголовков вида: == ййй ==
zagolovok_level2 = re.compile("==.*==") # жадный квантификатор .*
# --- регулярные выражения для внутренних ссылок вида [[id**|**]], [[club**|**]], [[public**|**]]
#ssylka_inner_tpl = re.compile("\[\[.*?\|.*?\]\]") # [[ | ]] нежадный кватнификатор .*?
ssylka_inner_id = re.compile("\[\[id.*?\|.*?\]\]") # id
ssylka_inner_club = re.compile("\[\[club.*?\|.*?\]\]") # club
ssylka_inner_public = re.compile("\[\[public.*?\|.*?\]\]") # public
# --- регулярное выражение для внешних ссылок вида [http**|**]
ssylka_outer = re.compile("\[http.*?\|.*?\]")
# --- регулярное выражение для вставки переноса на другую строку (если заканчивается на ":" + пробелы)
perenos = re.compile(":\s*$")
# --------
for stroka in f1.readlines(): #читаем входной файл построчно
# ---- Замена заголовков
if re.match(zagolovok_level2, stroka):
stroka = stroka.replace("==","##",1)
stroka = stroka.replace("==", "")
# ---- Замена жирного шрифта и курсива ----
stroka = stroka.replace("'''",'**') # жирный шрифт - переделать в регулярные выражения!
stroka = stroka.replace("''",'*') # курсив - переделать в регулярные выражения!
# ---- Замена внутренних ссылок (id, club, public) ----
iskomoe = (re.findall(ssylka_inner_id, stroka) +
re.findall(ssylka_inner_club, stroka) +
re.findall(ssylka_inner_public, stroka)) # находим все id,club,public
if iskomoe:
for ssylka in iskomoe: # перебираем найденные ссылки в строке
ssylka_id = ssylka.split("|")[0].replace('[[','') #выделяем id ссылки
|
ssylk
|
a_name = ssylka.split("|")[1].replace(']]','') #выделяем имя ссылки
ssylka_new = ('['+ssylka_name+']('+'http://vk.com/'+ssylka_id+')')
stroka = stroka.replace(ssylka, ssylka_new) #заменяем старую ссылку на новую
# ---- Замена внешних ссылок [http**|**] ----
iskomoe2 = re.findall(ssylka_outer, stroka)
if iskomoe2:
for ssylka2 in iskomoe2:
ssylka2_id = ssylka2.split("|")[0].replace('[http','http')
ssylka2_name = ssylka2.split("|")[1].replace(']','')
ssylka2_new = '['+ssylka2_name+']('+ssylka2_id+')'
stroka = stroka.replace(ssylka2, ssylka2_new)
# ---- Запись преобразованной строки в выходной файл ----
if re.search(perenos, stroka):
f2.write('\n' + stroka)
else:
f2.write(stroka)
# --------
f1.close()
f2.close()
|
inspectorbean/gasbuddy
|
home/views.py
|
Python
|
mit
| 14,960
| 0.008757
|
from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
import datetime, time, requests, re, os
import bs4
from django.contrib.admin.views.decorators import staff_member_required
from decimal import *
# Create your views here.
from .models import Gas, Region, Station, Site, Ship, Harvester, Setup, APICheck
from .forms import GasForm, SiteForm, SiteAnalyzer
def about(request):
return render(request, 'home/about.html')
def home(request):
if request.method == "POST":
form = GasForm(data=request.POST)
if form.is_valid():
data = form.cleaned_data
harv = data['harvester']
cycle = harv.cycle
yld = harv.yld
ship = data['ship']
yld_bonus = ship.yld_bonus
if data['skill'] > 5:
skill = 5
if data['skill'] < 1:
skill = 1
else:
skill = data['skill']
cycle_bonus = skill * .05
else:
form = GasForm()
cycle = 40
yld = 20
cycle_bonus = 0.25
yld_bonus = 1
if cycle_bonus > .25:
cycle_bonus = Decimal(0.25)
c = cycle * (1 - cycle_bonus)
y = yld * (1 + yld_bonus)
gases = Gas.objects.all()
isk_min = {}
for gas in gases:
g = gas.name
vol = gas.volume
isk_min_val = ((Decimal(y) / Decimal(gas.volume)) * 2) * (60 / Decimal(c)) * Decimal(gas.last_price)
isk_mthree = Decimal(gas.last_price) / Decimal(gas.volume)
isk_min[g] = [isk_min_val, isk_mthree]
u = APICheck.objects.get(id=1)
context = {'isk_min': isk_min, 'form': form, 'updated': str(u.updated)}
return render(request, "home/home.html", context)
def sites(request):
if request.method == "POST":
form = SiteForm(data=request.POST)
if form.is_valid():
data = form.cleaned_data
harv = data['harvester']
cycle = Decimal(harv.cycle)
yld = Decimal(harv.yld)
ship = data['ship']
yld_bonus = Decimal(ship.yld_bonus)
cargo = Decimal(ship.cargo)
num = Decimal(data['num'])
if data['skill'] > 5:
skill = 5
if data['skill'] < 1:
skill = 1
else:
skill = data['skill']
cycle_bonus = skill * .05
extra_data = data['extra_data']
else:
form = SiteForm()
cycle = Decimal(40)
yld = Decimal(20)
cycle_bonus = Decimal(0.25)
yld_bonus = Decimal(1)
num = Decimal(1)
cargo = 10000
extra_data = False
c = cycle * (Decimal(1) - Decimal(cycle_bonus))
y = yld * (Decimal(1) + Decimal(yld_bonus))
sites = Site.objects.all()
sites_calc = {}
for site in sites:
p_price = site.p_gas.last_price
s_price = site.s_gas.last_price
p_vol = site.p_gas.volume
s_vol = site.s_gas.volume
p_isk_min = ((Decimal(y) / Decimal(p_vol)) * 2) * (60 / Decimal(c)) * Decimal(p_price) * num
s_isk_min = ((Decimal(y) / Decimal(s_vol)) * 2) * (60 / Decimal(c)) * Decimal(s_price) * num
if p_isk_min < s_isk_min:
best_gas = site.s_gas
best_gas_isk_min = s_isk_min
best_qty = site.s_qty
other_gas = site.p_gas
other_gas_isk_min = p_isk_min
other_qty = site.p_qty
else:
best_gas = site.p_gas
best_gas_isk_min = p_isk_min
best_qty = site.p_qty
other_gas = site.s_gas
other_gas_isk_min = s_isk_min
other_qty = site.s_qty
p_units_min = ((y / best_gas.volume) * 2) * (60 / c) * num
s_units_min = ((y / other_gas.volume) * 2) * (60 / c) * num
time_to_clear = (best_qty / p_units_min) + (other_qty / s_units_min)
isk_pres = (p_price * site.p_qty) + (s_price * site.s_qty)
site_isk_min = Decimal(isk_pres) / Decimal(time_to_clear)
#extra data calculations
primary_time_to_clear = (best_qty / p_units_min)
secondary_time_to_clear = (other_qty / s_units_min)
#blue_loot_isk
#time to kill site
ships_needed = ((site.p_qty * p_vol) + (site.s_qty * s_vol)) / (cargo)
sites_calc[site.name] = [isk_pres, best_gas, best_gas_isk_min, other_gas, other_gas_isk_min, site_isk_min, time_to_clear, primary_time_to_clear, secondary_time_to_clear, ships_needed]
u = APICheck.objects.get(id=1)
context = {'form': form, 'sites_calc': sites_calc, 'updated': str(u.updated), 'extra_data': extra_data}
return render(request, "home/sites.html", context)
def site_an(request):
if request.method == 'POST':
form = SiteAnalyzer(data=request.POST)
if form.is_valid():
data = form.cleaned_data
scan = data['scan']
num = Decimal(data['num'])
ship = data['ship']
harvester = data['harvester']
skill = Decimal(data['skill'])
show_data = True
else:
form = SiteAnalyzer()
show_data = False
skill = 0
yld = 0
num = 1
ship = Ship.objects.get(id=1)
harvester = Harvester.objects.get(id=1)
cycle_bonus = skill * Decimal(0.05)
yld = harvester.yld
c = harvester.cycle * (1 - cycle_bonus)
y = yld * (1 + ship.yld_bonus) * num
#parse Dscan
sites = []
proc_sites = []
if show_data == True:
#print(scan)
scan_re = re.compile(r'Gas Site *(\S* \S* \S*) *')
scan_re_b = re.compile(r'(Instrumental Core Reservoir|Ordinary Perimeter Reservoir|Minor Perimeter Reservoir|Bountiful Frontier Reservoir|Barren Perimeter Reservoir|Token Perimeter Reservoir|Sizable Perimeter Reservoir|Vast Frontier Reservoir|Vital Core Reservoir)')
scan_results = scan_re.findall(scan)
if scan_results == []:
scan_results = scan_re_b.findall(scan)
print(scan_results)
for res in scan_results:
sites.append(res)
for s in sites:
site = Site.objects.get(name=s)
site_name = site.name
site_isk = (site.p_gas.last_price * site.p_qty) + (site.s_gas.last_price * site.s_qty)
#ninja scanning
#determine best gas
p_isk_min = ((Decimal(y) / Decimal(site.p_gas.volume)) * 2) * (60 / Decimal(c)) * Decimal(site.p_gas.last_price)
s_isk_min = ((Decimal(y) / Decimal(site.s_gas.volume)) * 2) * (60 / Decimal(c)) * Decimal(site.s_gas.last_price)
if p_isk_min >= s_isk_min:
first_cloud = site.p_gas
first_qty = site.p_qty
sec_cloud = site.s_gas
sec_qty = site.s_qty
if p_isk_min <= s_isk_min:
first_cloud = site.s_gas
first_qty = site.s_qty
sec_cloud = site.p_gas
sec_qty = site.p_qty
#calculate how much you can get in 15 minutes
units_15 = ((Decimal(y) / Decimal(first_cloud.volume)) * 2) * (60 / Decimal(c)) * 15
if units_15 <= first_qty:
ninja_isk = units_15 * first_cloud.last_price
if ninja_isk > site_isk:
ninja_isk = site_isk
m_per_s = (units_15 / num) * first_cloud.volume
#if it is more than the qty in the best cloud, calculate the remaining time
if units_15 > first_qty:
min_left = 15 - (first_qty / (units_15 / 15))
sec_units_min = ((Decimal(y) / Decimal(sec_cloud.volume)) * 2) * (60 / Decimal(c))
rem_units = sec_units_min * min_left
ninja_isk = (rem_units * sec_cloud.last_price) + (first_qt
|
y * first_cloud.last_price)
|
if ninja_isk > site_isk:
ninja_isk = site_isk
m_per_s = ((units_15 / num) * first_cloud.volume) + ((rem_units / num) * sec_cloud.volume)
if m_per_s * num > (site.p_qty * site.p_gas.volume) + (site.s_qty * site.s_gas.volume)
|
FrankNagel/qlc
|
src/webapp/quanthistling/quanthistling/tests/functional/test_book.py
|
Python
|
gpl-3.0
| 203
| 0.004926
|
fr
|
om quanthistling.tests import *
class TestBo
|
okController(TestController):
def test_index(self):
response = self.app.get(url(controller='book', action='index'))
# Test response...
|
WaveBlocks/WaveBlocksND
|
WaveBlocksND/ObservablesMixedHAWP.py
|
Python
|
bsd-3-clause
| 13,370
| 0.006806
|
"""The WaveBlocks Project
Compute some observables like norm, kinetic and potential energy
of Hagedorn wavepackets. This class implements the mixed case
where the bra does not equal the ket.
@author: R. Bourquin
@copyright: Copyright (C) 2014, 2016 R. Bourquin
@license: Modified BSD License
"""
from functools import partial
from numpy import squeeze, sum
from WaveBlocksND.Observables import Observables
__all__ = ["ObservablesMixedHAWP"]
class ObservablesMixedHAWP(Observables):
r"""This class implements the mixed case observable computation
:math:`\langle \Psi | \cdot | \Psi^{\prime} \rangle` for Hagedorn
wavepackets :math:`\Psi` where the bra :math:`\Psi` does not equal
the ket :math:`\Psi^{\prime}`.
"""
def __init__(self, *, innerproduct=None, gradient=None):
r"""Initialize a new :py:class:`ObservablesMixedHAWP` instance for observable computation of Hagedorn wavepackets.
"""
self._innerproduct = None
self._gradient = None
def set_innerproduct(self, innerproduct):
r"""Set the innerproduct.
:param innerproduct: An inner product for computing the integrals. The inner product is used
for the computation of all brakets
:math:`\langle \Psi | \cdot | \Psi^{\prime} \rangle`.
:type innerproduct: A :py:class:`InnerProduct` subclass instance.
.. note:: Make sure to use an inhomogeneous inner product here.
"""
self._innerproduct = innerproduct
def set_gradient(self, gradient):
r"""Set the gradient.
:param gradient: A gradient operator. The gradient is only used for the computation of the kinetic
|
energy :math:`\langle \Psi | T | \Psi^{\prime} \rangle`.
:type gradient: A :py:class:`Gradient` subclass instance.
"""
self._gradient = gradient
def overlap(self, pacbra, packet, *, component=None, summed=False):
r"""Calculate the overlap :math:`\langle \Psi | \Psi^{\prime} \rangle` of the wavepackets
:math:`\Psi` and :math:`\Psi^{\prime}`.
:param pacbra: The wavepacke
|
t :math:`\Psi` which takes part in the overlap integral.
:type pacbra: A :py:class:`HagedornWavepacketBase` subclass instance.
:param packet: The wavepacket :math:`\Psi^{\prime}` which takes part in the overlap integral.
:type packet: A :py:class:`HagedornWavepacketBase` subclass instance.
:param component: The index :math:`i` of the components :math:`\Phi_i` of :math:`\Psi`
and :math:`\Phi_i^{\prime}` of :math:`\Psi^{\prime}` whose overlap is
computed. The default value is ``None`` which means to compute the
overlaps with all :math:`N` components involved.
:type component: Integer or ``None``.
:param summed: Whether to sum up the overlaps :math:`\langle \Phi_i | \Phi_i^{\prime} \rangle`
of the individual components :math:`\Phi_i` and :math:`\Phi_i^{\prime}`.
:type summed: Boolean, default is ``False``.
:return: The overlap of :math:`\Psi` with :math:`\Psi^{\prime}` or the overlap of :math:`\Phi_i`
with :math:`\Phi_i^{\prime}` or a list with the :math:`N` overlaps of all components.
(Depending on the optional arguments.)
"""
return self._innerproduct.quadrature(pacbra, packet, diag_component=component, diagonal=True, summed=summed)
def norm(self, wavepacket, *, component=None, summed=False):
r"""Calculate the :math:`L^2` norm :math:`\langle \Psi | \Psi \rangle` of the wavepacket :math:`\Psi`.
:param wavepacket: The wavepacket :math:`\Psi` of which we compute the norm.
:type wavepacket: A :py:class:`HagedornWavepacketBase` subclass instance.
:param component: The index :math:`i` of the component :math:`\Phi_i` whose norm is computed.
The default value is ``None`` which means to compute the norms of all :math:`N` components.
:type component: int or ``None``.
:param summed: Whether to sum up the norms :math:`\langle \Phi_i | \Phi_i \rangle` of the
individual components :math:`\Phi_i`.
:type summed: Boolean, default is ``False``.
:return: The norm of :math:`\Psi` or the norm of :math:`\Phi_i` or a list with the :math:`N`
norms of all components. (Depending on the optional arguments.)
.. note:: This method just redirects to a call to :py:meth:`HagedornWavepacketBase.norm`.
"""
return wavepacket.norm(component=component, summed=summed)
def kinetic_overlap_energy(self, pacbra, packet, *, component=None, summed=False):
r"""Compute the kinetic energy overlap :math:`\langle \Psi | T | \Psi^{\prime} \rangle`
of the different components :math:`\Phi_i` and :math:`\Phi_i^{\prime}` of the
wavepackets :math:`\Psi` and :math:`\Psi^{\prime}`.
:param pacbra: The wavepacket :math:`\Psi` which takes part in the kinetic energy integral.
:type pacbra: A :py:class:`HagedornWavepacketBase` subclass instance.
:param packet: The wavepacket :math:`\Psi^{\prime}` which takes part in the kinetic energy integral.
:type packet: A :py:class:`HagedornWavepacketBase` subclass instance.
:param component: The index :math:`i` of the components :math:`\Phi_i` of :math:`\Psi`
and :math:`\Phi_i^{\prime}` of :math:`\Psi^{\prime}` which take part in the
kinetic energy integral. If set to ``None`` the computation is performed for
all :math:`N` components of :math:`\Psi` and :math:`\Psi^{\prime}`.
:type component: Integer or ``None``.
:param summed: Whether to sum up the kinetic energies :math:`E_i` of the individual
components :math:`\Phi_i` and :math:`\Phi_i^{\prime}`.
:type summed: Boolean, default is ``False``.
:return: A list of the kinetic energy overlap integrals of the individual components or
the overall kinetic energy overlap of the wavepackets. (Depending on the optional arguments.)
"""
Nbra = pacbra.get_number_components()
Nket = packet.get_number_components()
if not Nbra == Nket:
# TODO: Drop this requirement, should be easy when zip(...) exhausts
raise ValueError("Number of components in bra (%d) and ket (%d) differs!" % (Nbra, Nket))
if component is None:
components = range(Nbra)
else:
components = [component]
ekin = []
for n in components:
gradpacbra = self._gradient.apply_gradient(pacbra, component=n)
gradpacket = self._gradient.apply_gradient(packet, component=n)
Q = [self._innerproduct.quadrature(gpb, gpk, diag_component=n) for gpb, gpk in zip(gradpacbra, gradpacket)]
ekin.append(0.5 * sum(Q))
if summed is True:
ekin = sum(ekin)
elif component is not None:
# Do not return a list for specific single components
ekin = ekin[0]
return ekin
def kinetic_energy(self, wavepacket, *, component=None, summed=False):
r"""Compute the kinetic energy :math:`E_{\text{kin}} := \langle \Psi | T | \Psi \rangle`
of the different components :math:`\Phi_i` of the wavepacket :math:`\Psi`.
:param wavepacket: The wavepacket :math:`\Psi` of which we compute the kinetic energy.
:type wavepacket: A :py:class:`HagedornWavepacketBase` subclass instance.
:param component: The index :math:`i` of the component :math:`\Phi_i` whose
kinetic energy we compute. If set to ``None`` the
computation is performed for all :math:`N` components.
:type component: Integer or ``None``.
:param summed: Whether to sum up the kinetic energies :math:`E_i` of the individual
components :math:`\Phi_i`.
:type summed: Boolean, default i
|
crobinso/libvirt
|
scripts/hyperv_wmi_generator.py
|
Python
|
lgpl-2.1
| 10,347
| 0.001546
|
#!/usr/bin/env python3
#
# hyperv_wmi_generator.py: generates most of the WMI type mapping code
#
# Copyright (C) 2011 Matthias Bolte <[email protected]>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library. If not, see
# <http://www.gnu.org/licenses/>.
#
import sys
import os
import os.path
separator = "/*" + ("*" * 50) + "*\n"
wmi_classes_by_name = {}
class WmiClass:
"""Represents WMI class and provides methods to generate C code."""
def __init__(self, name, properties, uri_info):
self.name = name
self.properties = properties
self.uri_info = uri_info
def generate_classes_header(self):
"""Generate C header code and return it as string
Declares:
<class_name>_Data - used as hypervObject->data
<class_name>_TypeInfo - used as wsman XmlSerializerInfo
<class_name> - "inherits" hypervObject struct
"""
name_upper = self.name.upper()
header = separator
header += " * %s\n" % self.name
header += " */\n"
header += "\n"
header += "#define %s_WQL_SELECT \\\n" % name_upper
header += " \"SELECT * FROM %s \"\n" % self.name
header += "\n"
header += "extern hypervWmiClassInfo *%s_WmiInfo;\n\n" % self.name
header += self._declare_data_structs()
header += self._declare_hypervObject_struct()
return header
def generate_classes_source(self):
"""Returns a C code string defining wsman data structs
Defines:
<class_name>_Data struct
<class_name>_WmiInfo - list holding metadata (e.g. request URIs) for the WMI class
"""
source = separator
source += " * %s\n" % self.name
source += " */\n"
source += "SER_START_ITEMS(%s_Data)\n" % self.name
for property in self.properties:
source += property.generate_classes_source(self.name)
source += "SER_END_ITEMS(%s_Data);\n\n" % self.name
# also generate typemap data while we're here
source += "hypervCimType %s_Typemap[] = {\n" % self.name
for property in self.properties:
source += property.generate_typemap()
source += ' { "", "", 0 },\n' # null terminated
source += '};\n\n'
source += self._define_WmiInfo_struct()
source += "\n\n"
return source
def generate_classes_typedef(self):
"""Returns C string for typedefs"""
typedef = "typedef struct _%s %s;\n" % (self.name, self.name)
typedef += "typedef struct _%s_Data %s_Data;\n" % (self.name, self.name)
typedef += "G_DEFINE_AUTOPTR_CLEANUP_FUNC(%s, hypervFreeObject);\n" % self.name
typedef += "\n"
return typedef
def _declare_data_structs(self):
"""Returns string C code declaring data structs.
The *_Data structs are used as hypervObject->data. Each one has
corresponding *_TypeInfo that is us
|
ed for wsman unserialization of
response XML into the *_Data structs.
"""
header = "#define %s_RESO
|
URCE_URI \\\n" % self.name.upper()
header += " \"%s\"\n" % self.uri_info.resourceUri
header += "\n"
header += "struct _%s_Data {\n" % self.name
for property in self.properties:
header += property.generate_classes_header()
header += "};\n\n"
header += "SER_DECLARE_TYPE(%s_Data);\n" % self.name
return header
def _declare_hypervObject_struct(self):
"""Return string for C code declaring hypervObject instance"""
header = "\n/* must match hypervObject */\n"
header += "struct _%s {\n" % self.name
header += " %s_Data *data;\n" % self.name
header += " hypervWmiClassInfo *info;\n"
header += " %s *next;\n" % self.name
header += "};\n"
header += "\n\n\n"
return header
def _define_WmiInfo_struct(self):
"""Return string for C code defining *_WmiInfo struct
This struct holds info with meta-data needed to make wsman requests for the WMI class.
"""
source = "hypervWmiClassInfo *%s_WmiInfo = &(hypervWmiClassInfo) {\n" % self.name
source += " .name = \"%s\",\n" % self.name
source += " .rootUri = %s,\n" % self.uri_info.rootUri
source += " .resourceUri = %s_RESOURCE_URI,\n" % self.name.upper()
source += " .serializerInfo = %s_Data_TypeInfo,\n" % self.name
source += " .propertyInfo = %s_Typemap\n" % self.name
source += "};\n"
return source
class ClassUriInfo:
"""Prepares URI information needed for wsman requests."""
def __init__(self, wmi_name):
if wmi_name.startswith("Msvm_"):
self.rootUri = "ROOT_VIRTUALIZATION_V2"
baseUri = "http://schemas.microsoft.com/wbem/wsman/1/wmi/root/virtualization/v2"
else:
self.rootUri = "ROOT_CIMV2"
baseUri = "http://schemas.microsoft.com/wbem/wsman/1/wmi/root/cimv2"
self.resourceUri = "%s/%s" % (baseUri, wmi_name)
class Property:
typemap = {
"boolean": "BOOL",
"string": "STR",
"datetime": "STR",
"int8": "INT8",
"sint8": "INT8",
"int16": "INT16",
"sint16": "INT16",
"int32": "INT32",
"sint32": "INT32",
"int64": "INT64",
"sint64": "INT64",
"uint8": "UINT8",
"uint16": "UINT16",
"uint32": "UINT32",
"uint64": "UINT64"
}
def __init__(self, type, name, is_array):
if type not in Property.typemap:
report_error("unhandled property type %s" % type)
self.type = type
self.name = name
self.is_array = is_array
def generate_classes_header(self):
if self.is_array:
return " XML_TYPE_DYN_ARRAY %s;\n" % self.name
else:
return " XML_TYPE_%s %s;\n" \
% (Property.typemap[self.type], self.name)
def generate_classes_source(self, class_name):
if self.is_array:
return " SER_NS_DYN_ARRAY(%s_RESOURCE_URI, \"%s\", 0, 0, %s),\n" \
% (class_name.upper(), self.name, self.type)
else:
return " SER_NS_%s(%s_RESOURCE_URI, \"%s\", 1),\n" \
% (Property.typemap[self.type], class_name.upper(), self.name)
def generate_typemap(self):
return ' { "%s", "%s", %s },\n' % (self.name, self.type.lower(), str(self.is_array).lower())
def open_file(filename):
return open(filename, "wt")
def report_error(message):
print("error: " + message)
sys.exit(1)
def parse_class(block, number):
# expected format: class <name> : <optional parent>
header_items = block[0][1].split()
if len(header_items) not in [2, 4]:
report_error("line %d: invalid block header" % (number))
assert header_items[0] == "class"
name = header_items[1]
if name in wmi_classes_by_name:
report_error("class '%s' has already been defined" % name)
if len(header_items) == 4:
parent_class = header_items[3]
if parent_class not in wmi_classes_by_name:
report_error("nonexistent parent class specified: %s" % parent_class)
properties = wmi_classes_by_name[parent_class].properties.copy()
else:
properties = []
for line in block[1:]:
# expected format: <type> <name>
items = line[1].split()
if len(items) != 2:
report_error("line %d: invalid property" % line[0])
if item
|
shrinidhi666/rbhus
|
tests/conversationBox.py
|
Python
|
gpl-3.0
| 1,444
| 0.025623
|
#!/usr/bin/python
from PyQt4 import QtCore, QtGui
class Bubble(QtGui.QLabel):
def __init__(self,text):
super(Bubble,self).__init__(text)
self.setContentsMargins(5,5,5,5)
def paintEvent(self, e):
p = QtGui.QPainter(self)
p.setRenderHint(QtGui.QPainter.Antialiasing,True)
p.drawRoundedRect(0,0,self.width()-1,self.height()-1,5,5)
super(Bubble,self).paintEvent(e)
class MyWidget(QtGui.QWidget):
def __init__(self,text,left=True):
super(MyWidget,self).__init__()
hbox = QtGui.QHBoxLayout()
label = Bubble(text)
if left is not True:
hbox.addSpacerItem(QtGui.QSpa
|
cerItem(1,1
|
,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Preferred))
hbox.addWidget(label)
if left is True:
hbox.addSpacerItem(QtGui.QSpacerItem(1,1,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Preferred))
hbox.setContentsMargins(0,0,0,0)
self.setLayout(hbox)
self.setContentsMargins(0,0,0,0)
if __name__ == '__main__':
a = QtGui.QApplication([])
w = QtGui.QWidget()
vbox = QtGui.QVBoxLayout()
vbox.addWidget(MyWidget("Left side.. and also check everything needed to fuck around\n\n\n"))
vbox.addWidget(MyWidget("Right side",left=False))
vbox.addWidget(MyWidget("Left side"))
vbox.addWidget(MyWidget("Left side"))
w.setLayout(vbox)
w.show()
a.exec_()
|
mfherbst/spack
|
var/spack/repos/builtin/packages/r-sva/package.py
|
Python
|
lgpl-2.1
| 1,827
| 0.000547
|
##############################################################################
# Copyright (c) 2013-2018, Lawrence Livermore National Security, LLC.
# Produced at the Lawrence Livermore National Laboratory.
#
# This file is part of Spack.
# Created by Todd Gamblin, [email protected], All rights reserved.
# LLNL-CODE-647188
#
# For details, see https://github.com/spack/spack
# Please also see the NOTICE an
|
d LICENSE files for our notice and the LGPL.
#
# This program is free software; you can redistribute it and/or modify
# it u
|
nder the terms of the GNU Lesser General Public License (as
# published by the Free Software Foundation) version 2.1, February 1999.
#
# 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 terms and
# conditions of the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##############################################################################
from spack import *
class RSva(RPackage):
"""Surrogate Variable Analysis."""
homepage = "https://www.bioconductor.org/packages/sva/"
git = "https://git.bioconductor.org/packages/sva.git"
version('3.24.4', commit='ed2ebb6e33374dc9ec50e6ea97cc1d9aef836c73')
depends_on('[email protected]:3.4.9', when='@3.24.4')
depends_on('r-mgcv', type=('build', 'run'))
depends_on('r-genefilter', type=('build', 'run'))
depends_on('r-biocparallel', type=('build', 'run'))
depends_on('r-matrixstats', type=('build', 'run'))
depends_on('r-limma', type=('build', 'run'))
|
kumar303/hawkrest
|
hawkrest/__init__.py
|
Python
|
bsd-3-clause
| 7,011
| 0.000428
|
import logging
import sys
import traceback
from django.conf import settings
from django.core.cache import cache
try:
from django.utils.module_loading import import_string
except ImportError:
# compatibility with django < 1.7
from django.utils.module_loading import import_by_path
import_string = import_by_path
from mohawk import Receiver
from mohawk.exc import BadHeaderValue, HawkFail, TokenExpired
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from hawkrest.util import get_auth_header, is_hawk_request
log = logging.getLogger(__name__)
# Number of seconds until a Hawk message expires.
default_message_expiration = 60
def default_credentials_lookup(cr_id):
if cr_id not in settings.HAWK_CREDENTIALS:
raise LookupError('No Hawk ID of {id}'.format(id=cr_id))
return settings.HAWK_CREDENTIALS[cr_id]
def default_user_lookup(request, credentials):
return HawkAuthenticatedUser(), None
class HawkAuthentication(BaseAuthentication):
def hawk_credentials_lookup(self, cr_id):
lookup = default_credentials_lookup
lookup_name = getattr(
settings,
'HAWK_CREDENTIALS_LOOKUP',
None)
if lookup_name:
log.debug('Using custom credentials lookup from: {}'
.format(lookup_name))
lookup = import_string(lookup_name)
return lookup(cr_id)
def hawk_user_lookup(self, request, credentials):
lookup = default_user_lookup
lookup_name = getattr(
settings,
'HAWK_USER_LOOKUP',
None)
if lookup_name:
log.debug('Using custom user lookup from: {}'
.format(lookup_name))
lookup = import_string(lookup_name)
return lookup(request, credentials)
def authenticate(self, request):
# In case there is an exception, tell others that the view passed
# through Hawk authorization. The META dict is used because
# middleware may not get an identical request object.
# A dot-separated key is to work around potential environ var
# pollution of META.
request.META['hawk.receiver'] = None
http_authorization = get_auth_header(request)
if not http_authorization:
log.debug('no authorization header in request')
return None
elif not is_hawk_request(request):
log.debug('ignoring non-Hawk authorization header: {} '
.format(http_authorization))
return None
try:
receiver = Receiver(
lambda cr_id: self.hawk_credentials_lookup(cr_id),
http_authorization,
request.build_absolute_uri(),
request.method,
content=request.body,
seen_nonce=(seen_nonce
if getattr(settings, 'USE_CACHE_FOR_HAWK_NONCE',
True)
else None),
content_type=request.META.get('CONTENT_TYPE', ''),
timestamp_skew_in_seconds=getattr(settings,
'HAWK_MESSAGE_EXPIRATION',
default_message_expiration))
except HawkFail as e:
etype, val, tb = sys.exc_info()
log.debug(traceback.format_exc())
log.warning('access denied: {etype.__name__}: {val}'
.format(etype=etype, val=val))
# The exception message is sent to the client as part of the
# 401 response, so we're intentionally vague about the original
# exception type/value, to avoid assisting attackers.
msg = 'Hawk authentication failed'
if isinstance(e, BadHeaderValue):
msg += ': The request header was malformed'
elif isinstance(e, TokenExpired):
msg += ': The token has expired. Is your system clock correct?'
raise AuthenticationFailed(msg)
# Pass our receiver object to the middleware so the request header
# doesn't need to be parsed again.
request.META['hawk.receiver'] = receiver
return self.hawk_user_lookup(request, receiver.resource.credentials)
def authenticate_header(self, request):
return 'Hawk'
# Added for Django compatibility, allowing use of this class as a
# normal Django authentication backend as well (for views outside
# Django Rest Framework)
def get_user(self, user_id):
return HawkAuthenticatedUser()
class HawkAuthenticatedUser(object):
"""
A real-ish user like AbstractBaseUser but not a real Django model.
This passes the DRF is_authenticated permission check but it may cause
other problems. If you need to work with a real Django model user
you might need to subclass HawkAuthentication.
"""
is_active = True
def get_full_name(self):
return str(self.__class__.__name__)
def get_short_name(self):
return str(self.__class__.__name__)
def get_username(self):
return str(self.__class__.__name__)
def clean(self):
# There's nothing to clean, since the name is `self.__class__.__name__`.
pass
def save(self, *args, **kwargs):
raise NotImplementedError()
def natural_key(self):
return str(self.__class__.__name__)
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def set_password(self, password):
raise NotImplementedError()
def check_password(self, password):
raise NotImplementedError()
def set_unusable_password(self):
pass
def has_usable_password(self):
return False
def get_session_auth_hash(self):
raise NotImplementedError()
# -----------------------------------------------
# These methods are in older Django versions only:
# ---
|
--------------------------------------------
def get_previous_by_last_login(self, *args, **kw):
raise NotImplementedError()
|
def get_next_by_last_login(self, *args, **kw):
raise NotImplementedError()
def seen_nonce(id, nonce, timestamp):
"""
Returns True if the Hawk nonce has been seen already.
"""
key = '{id}:{n}:{ts}'.format(id=id, n=nonce, ts=timestamp)
if cache.get(key):
log.warning('replay attack? already processed nonce {k}'
.format(k=key))
return True
else:
log.debug('caching nonce {k}'.format(k=key))
cache.set(key, True,
# We only need the nonce until the message itself expires.
# This also adds a little bit of padding.
timeout=getattr(settings, 'HAWK_MESSAGE_EXPIRATION',
default_message_expiration) + 5)
return False
|
Degustare/cleany
|
cleany/maps/translation.py
|
Python
|
gpl-3.0
| 1,115
| 0.001795
|
# -*- coding: UTF-8 -*-
# translation.py
#
# Copyright (C) 2013 Cleany
#
# Author(s): Cédric Gaspoz <[email protected]>
#
# This file i
|
s part of cleany.
#
# Cleany is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Cleany 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 s
|
hould have received a copy of the GNU General Public License
# along with Cleany. If not, see <http://www.gnu.org/licenses/>.
# Stdlib imports
# Core Django imports
# Third-party app imports
from modeltranslation.translator import translator, TranslationOptions
# Cleany imports
#from .models import
# class AppellationTranslationOptions(TranslationOptions):
# fields = ('name', 'description',)
#
# translator.register(Appellation, AppellationTranslationOptions)
|
1905410/Misago
|
misago/users/management/commands/createsuperuser.py
|
Python
|
gpl-2.0
| 6,267
| 0.001277
|
"""
Misago-native rehash of Django's createsuperuser command that
works with double authentication fields on user model
"""
import sys
from getpass import getpass
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.core.management.base import BaseCommand
from django.db import DEFAULT_DB_ALIAS, IntegrityError
from django.utils.encoding import force_str
from django.utils.six.moves import input
from ...validators import validate_email, validate_password, validate_username
class NotRunningInTTYException(Exception):
pass
class Command(BaseCommand):
help = 'Used to create a superuser.'
def add_arguments(self, parser):
parser.add_argument('--username', dest='username', default=None,
help='Specifies the username for the superuser.')
parser.add_argument('--email', dest='email', default=None,
help='Specifies the username for the superuser.')
parser.add_argument('--password', dest='password', default=None,
help='Specifies the username for the superuser.')
parser.add_argument('--noinput', action='store_false', dest='interactive',
default=True,
help=('Tells Misago to NOT prompt the user for input '
'of any kind. You must use --username with '
'--noinput, along with an option for any other '
'required field. Superusers created with '
'--noinput will not be able to log in until '
'they\'re given a valid password.'))
parser.add_argument('--database', action='store', dest='database',
default=DEFAULT_DB_ALIAS,
help=('Specifies the database to use. '
'Default is "default".'))
def execute(self, *args, **options):
self.stdin = options.get('stdin', sys.stdin) # Used for testing
return super(Command, self).execute(*args, **options)
def handle(self, *args, **options):
username = options.get('username')
email = options.get('email')
password = options.get('password')
interactive = options.get('interactive')
verbosity = int(options.get('verbosity', 1))
# Validate initial inputs
if username is not None:
try:
username = username.strip()
validate_username(username)
except ValidationError as e:
self.stderr.write(e.messages[0])
username = None
if email is not None:
try:
email = email.strip()
validate_email(email)
except ValidationError as e:
self.stderr.write(e.messages[0])
email = None
if password is not None:
try:
password = password.strip()
validate_password(password)
except ValidationError as e:
self.stderr.write(e.messages[0])
password = None
if not interactive:
if username and email and password:
# Call User manager's create_superuser using our wrapper
self.create_superuser(username, email, password, verbosity)
else:
try:
if hasattr(self.stdin, 'isatty') and not self.stdin.isatty():
raise NotRunningInTTYException("Not running in a TTY")
# Prompt for username/password, and any other required fields.
# Enclose this whole thing in a try/except to trap for a
# keyboard interrupt and exit gracefully.
while not username:
try:
message = for
|
ce_str("Enter displayed username: ")
raw_value = input(message).strip()
validate_username(raw_value)
username = raw_value
except Val
|
idationError as e:
self.stderr.write(e.messages[0])
while not email:
try:
raw_value = input("Enter E-mail address: ").strip()
validate_email(raw_value)
email = raw_value
except ValidationError as e:
self.stderr.write(e.messages[0])
while not password:
try:
raw_value = getpass("Enter password: ").strip()
validate_password(raw_value)
repeat_raw_value = getpass("Repeat password: ").strip()
if raw_value != repeat_raw_value:
raise ValidationError(
"Entered passwords are different.")
password = raw_value
except ValidationError as e:
self.stderr.write(e.messages[0])
# Call User manager's create_superuser using our wrapper
self.create_superuser(username, email, password, verbosity)
except KeyboardInterrupt:
self.stderr.write("\nOperation cancelled.")
sys.exit(1)
except NotRunningInTTYException:
self.stdout.write(
"Superuser creation skipped due to not running in a TTY. "
"You can run `manage.py createsuperuser` in your project "
"to create one manually."
)
def create_superuser(self, username, email, password, verbosity):
try:
User = get_user_model()
user = User.objects.create_superuser(username, email, password,
set_default_avatar=True)
if verbosity >= 1:
message = "Superuser #%(pk)s has been created successfully."
self.stdout.write(message % {'pk': user.pk})
except ValidationError as e:
self.stderr.write(e.messages[0])
except IntegrityError as e:
self.stderr.write(e.messages[0])
|
kdaily/altanalyze
|
methylation.py
|
Python
|
apache-2.0
| 11,047
| 0.023264
|
###ExonArray
#Copyright 2005-2008 J. David Gladstone Institutes, San Francisco California
#Author Nathan Salomonis - [email protected]
#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitation the rights
#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#copies of the Software, and to permit persons to whom the Software is furnished
#to do so, subject to the following conditions:
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
#INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
#PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
#HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
#OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
#SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import sys, string
import os.path
import unique
import time
import export
def filepath(filename):
fn = unique.filepath(filename)
return fn
def read_directory(sub_dir):
dir_list = unique.read_directory(sub_dir)
#add in code to prevent folder names from being included
dir_list2 = []
for file in dir_list:
if '.txt' in file: dir_list2.append(file)
return dir_list2
################# Begin Analysis
def cleanUpLine(line):
line = string.replace(line,'\n','')
line = string.replace(line,'\c','')
data = string.replace(line,'\r','')
data = string.replace(data,'"','')
return data
def importAnnotations(filename):
firstLine = True
fn = filepath(filename)
rows = 0
for line in open(fn,'rU').xreadlines():
data = cleanUpLine(line);
tab_delimited_data = string.split(data,'\t')
if rows > 10: sys.exit()
print tab_delimited_data#;sys.exit()
rows+=1
def correlateMethylationData(filename,betaLow=0.4,betaHigh=0.6,counts=-1):
### Takes a filtered pre-processed beta-value file as input
firstLine = True
rows=0; filtered=0
for line in open(filename,'rU').xreadlines():
data = cleanUpLine(line);
t = string.split(data,'\t')
if firstLine:
header = t
if len(t)>5 and 'Illumina_name' in header:
delimiter = -50
annot_export_object.write(string.join([t[0]]+t[delimiter:],'\t')+'\n')
else:
delimiter = len(header)
headers = t[1:delimiter]
firstLine = False
export_object.write(string.join([t[0]]+headers,'\t')+'\n')
else:
probeID = t[0]
#try: beta_values = map(float,t[1:50])
beta_values = map(lambda x: conFloat(x,t[1:delimiter]),t[1:delimiter])
if '' in beta_values:
print beta_values;sys.exit()
high = sum(betaHighCount(x,betaHigh) for x in beta_values)
low = sum(betaLowCount(x,betaLow) for x in beta_values)
def importMethylationData(filename,betaLow=0.4,betaHigh=0.6,counts=-1, filter=None):
annot_file = filepath('AltDatabase/ucsc/Hs/Illumina_methylation_genes.txt')
export_object = open(filename[:-4]+'-filtered.txt','w')
print filename[:-4]+'-filtered.txt', counts
firstLine = True
rows=0; filtered=0
for line in open(filename,'rU').xreadlines():
data = cleanUpLine(line);
t = string.split(data,'\t')
#export_object.write(string.join(t,'\t')+'\n')
#"""
if firstLine:
header = t
if len(t)>5 and 'Illumina_name' in
|
header:
delimiter = -50
annot_export_object = open(annot_file,'w')
annot_export_object.write(string.join([t[0]]+t[delimiter:],'\t')+'\n')
else:
delimiter = len(header)
headers = t[1:delimiter]
firstLine = False
export_object.write(string.join([t[0]]+headers,'\t')+'\n')
else:
probeID = t[0]
#try: beta_values = map(float,t[1:50])
beta_val
|
ues = map(lambda x: conFloat(x,t[1:delimiter]),t[1:delimiter])
if '' in beta_values:
print beta_values;sys.exit()
high = sum(betaHighCount(x,betaHigh) for x in beta_values)
low = sum(betaLowCount(x,betaLow) for x in beta_values)
#if rows<50: print high, low, max(beta_values), min(beta_values)
#else:sys.exit()
#export_object.write(string.join(t[:delimiter])+'\n')
if high>=counts and low>=counts:
#if (high-low) > 0.2:
#if rows<50: print 1
if filter!=None:
if probeID in filter: proceed=True; probeID = str(filter[probeID])+':'+probeID
else: proceed = False
else: proceed = True
if proceed:
filtered+=1
export_object.write(string.join([probeID]+map(str,beta_values),'\t')+'\n')
if 'Illumina_name' in header:
annot_export_object.write(string.join([t[0]]+t[delimiter:],'\t')+'\n')
rows+=1
#"""
export_object.close()
if delimiter == '-50':
annot_export_object.close()
print filtered, rows
def conFloat(x,betaValues):
try: x = float(x)
except Exception: x=None
if x== None or x == 0:
floats=[]
for i in betaValues:
if i=='': pass
elif float(i)==0: pass
else: floats.append(float(i))
try: return min(floats)
except Exception: print betaValues;sys.exit()
else:
return x
def betaHighCount(x,betaHigh):
if x>betaHigh:
return 1
else: return 0
def betaLowCount(x,betaLow):
if x<betaLow:
return 1
else: return 0
def getIDsFromFile(filename):
filterIDs = {}
fn = filepath(filename)
for line in open(fn,'rU').xreadlines():
data = cleanUpLine(line);
t = string.split(data,'\t')
filterIDs[string.lower(t[0])]=[]
return filterIDs
def getRegionType(filename,featureType=None,chromosome=None,filterIDs=None):
if filterIDs !=None:
filterIDs = getIDsFromFile(filterIDs)
firstLine = True
fn = filepath(filename)
count=0; filter_db={}
for line in open(fn,'rU').xreadlines():
data = cleanUpLine(line);
t = string.split(data,',')
if firstLine:
if len(t[2]) >0:
header = t
firstLine=False
chr_ind = header.index('CHR')
pos_ind = header.index('Coordinate_36')
tss_ind = header.index('UCSC_RefGene_Group')
gene_name = header.index('UCSC_RefGene_Name')
else:
probeID = t[0]
count+=1
try: gene_names = string.split(t[gene_name],';')
except Exception: gene_names = []
try:
if chromosome != None:
if t[chr_ind] == chromosome:
if filterIDs !=None:
for gene in gene_names:
if string.lower(gene) in filterIDs:
filter_db[probeID]=t[pos_ind]
else:
filter_db[probeID]=t[pos_ind]
if 'promoter' in string.lower(featureType):
if 'TSS' in t[tss_ind]:
if filterIDs !=None:
for gene in gene_names:
if string.lower(gene) in filterIDs:
filter_db[probeID]=t[pos_ind]
else:
filter_db
|
dongnizh/tika-python
|
tika/tests/tests_params.py
|
Python
|
apache-2.0
| 2,555
| 0.007828
|
#!/usr/bin/env python2.7
# encoding: utf-8
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You
|
under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by
|
applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#Reference
#https://docs.python.org/2/library/unittest.html
#http://eli.thegreenplace.net/2011/08/02/python-unit-testing-parametrized-test-cases
#public domain license reference: http://eli.thegreenplace.net/pages/code
#Run
#python tika/tests/tests_params.py
import csv
import unittest
import tika.parser
class CreateTest(unittest.TestCase):
"test for file types"
def __init__(self, methodName='runTest', param1=None, param2=None):
super(CreateTest, self).__init__(methodName)
self.param1 = param1
@staticmethod
def parameterize(test_case, param1=None, param2=None):
testloader = unittest.TestLoader()
testnames = testloader.getTestCaseNames(test_case)
suite = unittest.TestSuite()
for name in testnames:
suite.addTest(test_case(name, param1=param1, param2=param2))
return suite
class RemoteTest(CreateTest):
def setUp(self):
self.param1 = tika.parser.from_file(self.param1)
def test_true(self):
self.assertTrue(self.param1)
def test_meta(self):
self.assertTrue(self.param1['metadata'])
def test_content(self):
self.assertTrue(self.param1['content'])
def test_url():
with open('tika/tests/arguments/test_remote_content.csv', 'r') as csvfile:
urlread = csv.reader(csvfile)
for url in urlread:
yield url[1]
if __name__ == '__main__':
suite = unittest.TestSuite()
t_urls = list(test_url())
t_urls.pop(0) #remove header
for x in t_urls:
try:
suite.addTest(CreateTest.parameterize(RemoteTest,param1=x))
except IOError as e:
print(e.strerror)
unittest.TextTestRunner(verbosity=2).run(suite)
|
PaddlePaddle/Paddle
|
python/paddle/fluid/tests/unittests/test_exponential_op.py
|
Python
|
apache-2.0
| 7,870
| 0.000381
|
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import paddle
import numpy as np
from op_test import OpTest
import os
paddle.enable_static()
paddle.seed(100)
class TestExponentialOp1(OpTest):
def setUp(self):
self.op_type = "exponential"
self.config()
self.attrs = {"lambda": self.lam}
self.inputs = {'X': np.empty([1024, 1024], dtype=self.dtype)}
self.outputs = {'Out': np.ones([1024, 1024], dtype=self.dtype)}
def config(self):
self.lam = 0.5
self.dtype = "float64"
def test_check_output(self):
self.check_output_customized(self.verify_output)
def verify_output(self, outs):
hist1, _ = np.histogram(outs[0], range=(0, 5))
hist1 = hist1.astype("float32")
hist1 = hist1 / float(outs[0].size)
data_np = np.random.exponential(1. / self.lam, [1024, 1024])
hist2, _ = np.histogram(data_np, range=(0, 5))
hist2 = hi
|
st2.astype("float32")
hist2 = hist2 / float(data_np.size)
self.assertTrue(
np.allclose(
hist1, hist2, rtol=0.02),
"actual:
|
{}, expected: {}".format(hist1, hist2))
def test_check_grad_normal(self):
self.check_grad(
['X'],
'Out',
user_defined_grads=[np.zeros(
[1024, 1024], dtype=self.dtype)],
user_defined_grad_outputs=[
np.random.rand(1024, 1024).astype(self.dtype)
])
class TestExponentialOp2(TestExponentialOp1):
def config(self):
self.lam = 0.25
self.dtype = "float32"
class TestExponentialAPI(unittest.TestCase):
def test_static(self):
with paddle.static.program_guard(paddle.static.Program(),
paddle.static.Program()):
x_np = np.full([10, 10], -1.)
x = paddle.static.data(name="X", shape=[10, 10], dtype='float64')
x.exponential_(1.0)
exe = paddle.static.Executor()
out = exe.run(paddle.static.default_main_program(),
feed={"X": x_np},
fetch_list=[x])
self.assertTrue(np.min(out) >= 0)
def test_dygraph(self):
paddle.disable_static()
x = paddle.full([10, 10], -1., dtype='float32')
x.exponential_(0.5)
self.assertTrue(np.min(x.numpy()) >= 0)
paddle.enable_static()
def test_fixed_random_number(self):
# Test GPU Fixed random number, which is generated by 'curandStatePhilox4_32_10_t'
if not paddle.is_compiled_with_cuda():
return
# Different GPU generatte different random value. Only test V100 here.
if not "V100" in paddle.device.cuda.get_device_name():
return
if os.getenv("FLAGS_use_curand", None) in ('0', 'False', None):
return
print("Test Fixed Random number on V100 GPU------>")
paddle.disable_static()
paddle.set_device('gpu')
paddle.seed(2021)
x = paddle.empty([64, 3, 1024, 1024], dtype="float32")
x.exponential_(1.0)
x_np = x.numpy()
expect = [
0.80073667, 0.2249291, 0.07734892, 1.25392, 0.14013891, 0.45736602,
1.9735607, 0.30490234, 0.57100505, 0.8115938
]
self.assertTrue(np.allclose(x_np[0, 0, 0, 0:10], expect))
expect = [
1.4296371e+00, 9.5411777e-01, 5.2575850e-01, 2.4805880e-01,
1.2322118e-04, 8.4604341e-01, 2.1111444e-01, 1.4143821e+00,
2.8194717e-01, 1.1360573e+00
]
self.assertTrue(np.allclose(x_np[16, 1, 300, 200:210], expect))
expect = [
1.3448033, 0.35146526, 1.7380928, 0.32012638, 0.10396296,
0.51344526, 0.15308502, 0.18712929, 0.03888268, 0.20771872
]
self.assertTrue(np.allclose(x_np[32, 1, 600, 500:510], expect))
expect = [
0.5107464, 0.20970327, 2.1986802, 1.580056, 0.31036147, 0.43966478,
0.9056133, 0.30119267, 1.4797124, 1.4319834
]
self.assertTrue(np.allclose(x_np[48, 2, 900, 800:810], expect))
expect = [
3.4640615, 1.1019983, 0.41195083, 0.22681557, 0.291846, 0.53617656,
1.5791925, 2.4645927, 0.04094889, 0.9057725
]
self.assertTrue(np.allclose(x_np[63, 2, 1023, 1000:1010], expect))
x = paddle.empty([10, 10], dtype="float32")
x.exponential_(3.0)
x_np = x.numpy()
expect = [
0.02831675, 0.1691551, 0.6798956, 0.69347525, 0.0243443, 0.22180498,
0.30574575, 0.9839696, 0.2834912, 0.59420055
]
self.assertTrue(np.allclose(x_np[5, 0:10], expect))
x = paddle.empty([16, 2, 1024, 768], dtype="float64")
x.exponential_(0.25)
x_np = x.numpy()
expect = [
10.0541229, 12.67860643, 1.09850734, 7.35289643, 2.65471225,
3.86217432, 2.97902086, 2.92744479, 2.67927152, 0.19667352
]
self.assertTrue(np.allclose(x_np[0, 0, 0, 100:110], expect))
expect = [
0.68328125, 3.1454553, 0.92158376, 1.95842188, 1.05296941,
12.93242051, 5.20255978, 3.3588624, 1.57377174, 5.73194183
]
self.assertTrue(np.allclose(x_np[4, 0, 300, 190:200], expect))
expect = [
1.37973974, 3.45036798, 7.94625406, 1.62610973, 0.31032122,
4.13596493, 1.98494535, 1.13207041, 8.30592769, 2.81460147
]
self.assertTrue(np.allclose(x_np[8, 1, 600, 300:310], expect))
expect = [
2.27710811, 12.25003028, 2.96409124, 4.72405788, 0.67917249,
4.35856718, 0.46870976, 2.31120149, 9.61595826, 4.64446271
]
self.assertTrue(np.allclose(x_np[12, 1, 900, 500:510], expect))
expect = [
0.95883744, 1.57316361, 15.22524512, 20.49559882, 13.70008548,
3.29430143, 3.90390424, 0.9146657, 0.80972249, 0.33376219
]
self.assertTrue(np.allclose(x_np[15, 1, 1023, 750:760], expect))
x = paddle.empty([512, 768], dtype="float64")
x.exponential_(0.3)
x_np = x.numpy()
expect = [
8.79266704, 4.79596009, 2.75480243, 6.04670011, 0.35379556,
0.76864868, 3.17428251, 0.26556859, 12.22485885, 10.51690383
]
self.assertTrue(np.allclose(x_np[0, 200:210], expect))
expect = [
5.6341126, 0.52243418, 5.36410796, 6.83672002, 11.9243311,
5.85985566, 5.75169548, 0.13877972, 6.1348385, 3.82436519
]
self.assertTrue(np.allclose(x_np[300, 400:410], expect))
expect = [
4.94883581, 0.56345306, 0.85841585, 1.92287801, 6.10036656,
1.19524847, 3.64735434, 5.19618716, 2.57467974, 3.49152791
]
self.assertTrue(np.allclose(x_np[500, 700:710], expect))
x = paddle.empty([10, 10], dtype="float64")
x.exponential_(4.0)
x_np = x.numpy()
expect = [
0.15713826, 0.56395964, 0.0680941, 0.00316643, 0.27046853,
0.19852724, 0.12776634, 0.09642974, 0.51977551, 1.33739699
]
self.assertTrue(np.allclose(x_np[5, 0:10], expect))
paddle.enable_static()
if __name__ == "__main__":
unittest.main()
|
g-rauhoeft/scrap-cap
|
motioncapture/gui/GL/Shapes.py
|
Python
|
mit
| 1,040
| 0.025
|
from OpenGL import GL
import numpy as np
import math
def drawLine(start, end, color, width=1):
GL.glLineWidth(width)
GL.glColor3f(*color)
GL.glBegin(GL.GL_LINES)
GL.glVertex3f(*start)
GL.glVertex3f(*end)
GL.glEnd()
def drawCircle(center, radius, color, rotation=np.array([0,0,0]), axis=np.array([1,1,1]), width=1, sections = 16):
GL.glLineWidth(width)
GL.glColor3f(*color)
GL.glPushMatrix()
GL.glTranslatef(*center)
if not type(rotation) is int:
GL.glRotatef(rotation[0]*90,axis[0],0,0)
GL.glRotatef(rotation[1]*90,0,axis[1],0)
|
GL.glRotatef(rotation[2]*90,0,0,axis[2])
else:
GL.glRotatef(rotation*90,axis[0],axis[1],axis[2])
GL.glBegin(GL.GL_POLYGON)
steps = [i * ((math.pi*2)/sections) for i in range(sections)]
for i in steps:
GL.glVertex3f(math.cos(i)*radius, math.sin(i)*radius, 0,0)
GL.glEnd()
GL.glPopMatrix()
def makeDrawFunction(drawFunction, *args):
def closu
|
re():
drawFunction(*args)
return closure
|
ShapeNet/JointEmbedding
|
src/image_embedding_testing/extract_image_embedding.py
|
Python
|
bsd-3-clause
| 1,866
| 0.010718
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import sys
import numpy as np
import argparse
from google.protobuf import text_format
#https://github.com/BVLC/caffe/issues/861#issuecomment-70124809
import matplotlib
matplotlib.use('Agg')
BASE_DIR = os.path.dirna
|
me(os.path.abspath(__file__))
sys.path.append(os.path.dirname(BASE_DIR))
from global_variables import *
from utilities_caffe import *
parser = argparse.ArgumentParser(description="Extract image embedding features for IMAGE input.")
parser.add_argument('--image', help='Path to input image (cropped)', required=True)
parser.add_argument('--iter_num', '-n', help='Use caffemodel trained after iter_num iterations', type=int, default=200
|
00)
parser.add_argument('--caffemodel', '-c', help='Path to caffemodel (will ignore -n option if provided)', required=False)
parser.add_argument('--prototxt', '-p', help='Path to prototxt (if not at the default place)', required=False)
parser.add_argument('--gpu_index', help='GPU index (default=0).', type=int, default=0)
args = parser.parse_args()
image_embedding_caffemodel = os.path.join(g_image_embedding_testing_folder, 'snapshots%s_iter_%d.caffemodel'%(g_shapenet_synset_set_handle, args.iter_num))
image_embedding_prototxt = g_image_embedding_testing_prototxt
if args.caffemodel:
image_embedding_caffemodel = args.caffemodel
if args.prototxt:
image_embedding_prototxt = args.prototxt
print 'Image embedding for %s is:'%(args.image)
image_embedding_array = extract_cnn_features(img_filelist=args.image,
img_root='/',
prototxt=image_embedding_prototxt,
caffemodel=image_embedding_caffemodel,
feat_name='image_embedding',
caffe_path=g_caffe_install_path,
mean_file=g_mean_file)[0]
print image_embedding_array.tolist()
|
SaturdayNeighborhoodHealthClinic/osler
|
referral/migrations/0001_initial.py
|
Python
|
gpl-3.0
| 5,790
| 0.004836
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.1 on 2018-10-26 01:35
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
('pttrack', '0006_referral_additional_fields_20180826'),
('followup', '0002_simplehistory_add_change_reason'),
]
operations = [
migrations.CreateModel(
name='FollowupRequest',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('written_datetime', models.DateTimeField(auto_now_add=True)),
('last_modified', models.DateTimeField(auto_now=True)),
('completion_date', models.DateTimeField(blank=True, null=True)),
('due_date', models.DateField(help_text=b'MM/DD/YYYY or YYYY-MM-DD')),
('contact_instructions', models.TextField()),
('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Provider')),
('author_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.ProviderType')),
('completion_author', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='referral_followuprequest_completed', to='pttrack.Provider')),
('patient', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Patient')),
],
options={
'abstract': False,
},
),
migrations.CreateModel(
name='PatientContact',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('written_datetime', models.DateTimeField(auto_now_add=True)),
('last_modified', models.DateTimeField(auto_now=True)),
('has_appointment', models.CharField(blank=True, choices=[(b'Y', b'Yes'), (b'N', b'No')], help_text=b'Did the patient make an appointment?', max_length=1, verbose_name=b'Appointment scheduled?')),
('pt_showed', models.CharField(blank=True, choices=[(b'Y', b'Yes'), (b'N', b'No')], help_text=b'Did the patient show up to the
|
appointment?', max_length=1, null=True, verbose_name=b'Appointment attended?')),
('appointment_location', models.ManyToManyField(blank=True, help_text=b'Where did the patient make an appointment?', to='pttrack.ReferralLocation')),
('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Provider')),
('author_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.ProviderType')),
|
('contact_method', models.ForeignKey(help_text=b'What was the method of contact?', on_delete=django.db.models.deletion.CASCADE, to='pttrack.ContactMethod')),
('contact_status', models.ForeignKey(help_text=b'Did you make contact with the patient about this referral?', on_delete=django.db.models.deletion.CASCADE, to='followup.ContactResult')),
('followup_request', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='referral.FollowupRequest')),
('no_apt_reason', models.ForeignKey(blank=True, help_text=b"If the patient didn't make an appointment, why not?", null=True, on_delete=django.db.models.deletion.CASCADE, to='followup.NoAptReason', verbose_name=b'No appointment reason')),
('no_show_reason', models.ForeignKey(blank=True, help_text=b"If the patient didn't go to the appointment, why not?", null=True, on_delete=django.db.models.deletion.CASCADE, to='followup.NoShowReason')),
('patient', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Patient')),
],
options={
'abstract': False,
},
),
migrations.CreateModel(
name='Referral',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('written_datetime', models.DateTimeField(auto_now_add=True)),
('last_modified', models.DateTimeField(auto_now=True)),
('comments', models.TextField(blank=True)),
('status', models.CharField(choices=[(b'S', b'Successful'), (b'P', b'Pending'), (b'U', b'Unsuccessful')], default=b'P', max_length=50)),
('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Provider')),
('author_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.ProviderType')),
('kind', models.ForeignKey(help_text=b'The kind of care the patient should recieve at the referral location.', on_delete=django.db.models.deletion.CASCADE, to='pttrack.ReferralType')),
('location', models.ManyToManyField(to='pttrack.ReferralLocation')),
('patient', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='pttrack.Patient')),
],
options={
'abstract': False,
},
),
migrations.AddField(
model_name='patientcontact',
name='referral',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='referral.Referral'),
),
migrations.AddField(
model_name='followuprequest',
name='referral',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='referral.Referral'),
),
]
|
kencochrane/scorinator
|
scorinator/scorinator/settings/prod.py
|
Python
|
apache-2.0
| 2,973
| 0.001345
|
import os
from .base import * # NOQA
import dj_database_url
DEBUG = False
TEMPLATE_DEBUG = DEBUG
ADMINS = (
)
DATABASES = {'default': dj_database_url.config()}
LOGGING = {
'version': 1,
'disable_existing_loggers': True,
'filters': {
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse'
}
},
'formatters': {
'verbose': {
'format': '%(levelname)s %(asctime)s %(module)s '
'%(process)d %(thread)d %(message)s'
},
'simple': {
'format': '%(levelname)s %(message)s'
},
},
'handlers': {
'null': {
'level': 'DEBUG',
'class': 'django.utils.log.NullHandler',
},
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'verbose'
},
'mail_admins': {
'level': 'ERROR',
'filters': ['require_debug_false'],
'class': 'django.utils.log.AdminEmailHandler'
}
},
'loggers': {
'django': {
'handlers': ['console', 'mail_admins'],
'level': 'DEBUG',
'propagate': True,
},
'django.request': {
'handlers': ['console', 'mail_admins'],
'level': 'ERROR',
'propagate': False,
},
'django.db.backends': {
'handlers': ['console', 'mail_admins'],
'level': 'INFO',
'propagate': False,
},
# Catch All Logger -- Captures any other logging
'': {
'handlers': ['console', 'mail_admins'],
'level': 'DEBUG',
'propagate': True,
}
}
}
# Honor the 'X-Forwarded-Proto' header for request.is_secure()
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# Allow all host headers
ALLOWED_HOSTS = ['*']
########## EMAIL CONFIGURATION
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#email-backend
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#email-host
EMAIL_HOST = os.environ.get('MAILGUN_SMTP_SERVER', None)
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#email-host-password
EMAIL_HOST_PASSWORD = os.environ.get('MAILGUN_SMTP_PASSWORD', None)
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#email-host-user
EMAIL_HOST_USER = os.environ.get('MAILGUN_SMTP_LOGIN', None)
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#e
|
mail-port
EMAIL_PORT = os.environ.get('MAILGUN_SMTP_PORT', None )
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#email-subject-prefix
EMAIL_SUBJECT_PREFIX = '[Scorinator] '
# See: https://d
|
ocs.djangoproject.com/en/1.3/ref/settings/#email-use-tls
EMAIL_USE_TLS = True
# See: https://docs.djangoproject.com/en/1.3/ref/settings/#server-email
SERVER_EMAIL = EMAIL_HOST_USER
########## END EMAIL CONFIGURATION
|
aisk/grumpy
|
third_party/pypy/_sha512.py
|
Python
|
apache-2.0
| 14,181
| 0.062125
|
"""
This code was Ported from CPython's sha512module.c
"""
import _struct as struct
SHA_BLOCKSIZE = 128
SHA_DIGESTSIZE = 64
def new_shaobject():
return {
'digest': [0]*8,
'count_lo': 0,
'count_hi': 0,
'data': [0]* SHA_BLOCKSIZE,
'local': 0,
'digestsize': 0
}
ROR64 = lambda x, y: (((x & 0xffffffffffffffff) >> (y
|
& 63)) | (x << (64 - (y & 63)))) & 0xffffffffffffffff
Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
Maj = lambda x, y, z: (((x | y) & z) | (x & y))
S = lambda x, n: ROR64(x, n)
R = lambda x, n: (x & 0xffffffffffffffff) >> n
Sigma0 = lambda x: (S(x, 28) ^ S(x, 34) ^ S(x, 39))
Sigma1 = lambda x: (S(x, 14) ^ S(x, 18) ^ S(x, 41))
Gamma0 = lambda x: (S(x, 1)
|
^ S(x, 8) ^ R(x, 7))
Gamma1 = lambda x: (S(x, 19) ^ S(x, 61) ^ R(x, 6))
def sha_transform(sha_info):
W = []
d = sha_info['data']
for i in xrange(0,16):
W.append( (d[8*i]<<56) + (d[8*i+1]<<48) + (d[8*i+2]<<40) + (d[8*i+3]<<32) + (d[8*i+4]<<24) + (d[8*i+5]<<16) + (d[8*i+6]<<8) + d[8*i+7])
for i in xrange(16,80):
W.append( (Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xffffffffffffffff )
ss = sha_info['digest'][:]
def RND(a,b,c,d,e,f,g,h,i,ki):
t0 = (h + Sigma1(e) + Ch(e, f, g) + ki + W[i]) & 0xffffffffffffffff
t1 = (Sigma0(a) + Maj(a, b, c)) & 0xffffffffffffffff
d = (d + t0) & 0xffffffffffffffff
h = (t0 + t1) & 0xffffffffffffffff
return d & 0xffffffffffffffff, h & 0xffffffffffffffff
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],0,0x428a2f98d728ae22)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],1,0x7137449123ef65cd)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],2,0xb5c0fbcfec4d3b2f)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],3,0xe9b5dba58189dbbc)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],4,0x3956c25bf348b538)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],5,0x59f111f1b605d019)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],6,0x923f82a4af194f9b)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],7,0xab1c5ed5da6d8118)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],8,0xd807aa98a3030242)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],9,0x12835b0145706fbe)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],10,0x243185be4ee4b28c)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],11,0x550c7dc3d5ffb4e2)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],12,0x72be5d74f27b896f)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],13,0x80deb1fe3b1696b1)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],14,0x9bdc06a725c71235)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],15,0xc19bf174cf692694)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],16,0xe49b69c19ef14ad2)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],17,0xefbe4786384f25e3)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],18,0x0fc19dc68b8cd5b5)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],19,0x240ca1cc77ac9c65)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],20,0x2de92c6f592b0275)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],21,0x4a7484aa6ea6e483)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],22,0x5cb0a9dcbd41fbd4)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],23,0x76f988da831153b5)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],24,0x983e5152ee66dfab)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],25,0xa831c66d2db43210)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],26,0xb00327c898fb213f)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],27,0xbf597fc7beef0ee4)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],28,0xc6e00bf33da88fc2)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],29,0xd5a79147930aa725)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],30,0x06ca6351e003826f)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],31,0x142929670a0e6e70)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],32,0x27b70a8546d22ffc)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],33,0x2e1b21385c26c926)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],34,0x4d2c6dfc5ac42aed)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],35,0x53380d139d95b3df)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],36,0x650a73548baf63de)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],37,0x766a0abb3c77b2a8)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],38,0x81c2c92e47edaee6)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],39,0x92722c851482353b)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],40,0xa2bfe8a14cf10364)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],41,0xa81a664bbc423001)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],42,0xc24b8b70d0f89791)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],43,0xc76c51a30654be30)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],44,0xd192e819d6ef5218)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],45,0xd69906245565a910)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],46,0xf40e35855771202a)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],47,0x106aa07032bbd1b8)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],48,0x19a4c116b8d2d0c8)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],49,0x1e376c085141ab53)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],50,0x2748774cdf8eeb99)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],51,0x34b0bcb5e19b48a8)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],52,0x391c0cb3c5c95a63)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],53,0x4ed8aa4ae3418acb)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],54,0x5b9cca4f7763e373)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],55,0x682e6ff3d6b2b8a3)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],56,0x748f82ee5defb2fc)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],57,0x78a5636f43172f60)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],58,0x84c87814a1f0ab72)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],59,0x8cc702081a6439ec)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],60,0x90befffa23631e28)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],61,0xa4506cebde82bde9)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],62,0xbef9a3f7b2c67915)
ss[4], ss[0] = RND(ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],63,0xc67178f2e372532b)
ss[3], ss[7] = RND(ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],64,0xca273eceea26619c)
ss[2], ss[6] = RND(ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],ss[6],65,0xd186b8c721c0c207)
ss[1], ss[5] = RND(ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],ss[5],66,0xeada7dd6cde0eb1e)
ss[0], ss[4] = RND(ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],ss[4],67,0xf57d4f7fee6ed178)
ss[7], ss[3] = RND(ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],ss[3],68,0x06f067aa72176fba)
ss[6], ss[2] = RND(ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],ss[2],69,0x0a637dc5a2c898a6)
ss[5], ss[1] = RND(ss[2],ss[3],ss[4],ss[5],ss[6],ss[7],ss[0],ss[1],70,0x113f9804bef90d
|
ArcherSys/ArcherSys
|
Lib/configparser.py
|
Python
|
mit
| 148,451
| 0.000626
|
<<<<<<< HEAD
<<<<<<< HEAD
"""Configuration file parser.
A configuration file consists of sections, lead by a "[section]" header,
and followed by "name: value" entries, with continuations and such in
the style of RFC 822.
Intrinsic defaults can be specified by passing them into the
ConfigParser constructor as a dictionary.
class:
ConfigParser -- responsible for parsing a list of
configuration files, and managing the parsed database.
methods:
__init__(defaults=None, dict_type=_default_dict, allow_no_value=False,
delimiters=('=', ':'), comment_prefixes=('#', ';'),
inline_comment_prefixes=None, strict=True,
empty_lines_in_values=True):
Create the parser. When `defaults' is given, it is initialized into the
dictionary or intrinsic defaults. The keys must be strings, the values
must be appropriate for %()s string interpolation.
When `dict_type' is given, it will be used to create the dictionary
objects for the list of sections, for the options within a section, and
for the default values.
When `delimiters' is given, it will be used as the set of substrings
that divide keys from values.
When `comment_prefixes' is given, it will be used as the set of
substrings that prefix comments in empty lines. Comments can be
indented.
When `inline_comment_prefixes' is given, it will be used as the set of
substrings that prefix comments in non-empty lines.
When `strict` is True, the parser won't allow for any section or option
dupli
|
cates while reading from a single source (file, string or
dictionary). Default is True.
When `empty_lines_in_values' is False (default: True), each empty line
marks the end of an option. Otherwise, internal empty lines of
a multiline option are k
|
ept as part of the value.
When `allow_no_value' is True (default: False), options without
values are accepted; the value presented for these is None.
sections()
Return all the configuration section names, sans DEFAULT.
has_section(section)
Return whether the given section exists.
has_option(section, option)
Return whether the given option exists in the given section.
options(section)
Return list of configuration options for the named section.
read(filenames, encoding=None)
Read and parse the list of named configuration files, given by
name. A single filename is also allowed. Non-existing files
are ignored. Return list of successfully read files.
read_file(f, filename=None)
Read and parse one configuration file, given as a file object.
The filename defaults to f.name; it is only used in error
messages (if f has no `name' attribute, the string `<???>' is used).
read_string(string)
Read configuration from a given string.
read_dict(dictionary)
Read configuration from a dictionary. Keys are section names,
values are dictionaries with keys and values that should be present
in the section. If the used dictionary type preserves order, sections
and their keys will be added in order. Values are automatically
converted to strings.
get(section, option, raw=False, vars=None, fallback=_UNSET)
Return a string value for the named option. All % interpolations are
expanded in the return values, based on the defaults passed into the
constructor and the DEFAULT section. Additional substitutions may be
provided using the `vars' argument, which must be a dictionary whose
contents override any pre-existing defaults. If `option' is a key in
`vars', the value from `vars' is used.
getint(section, options, raw=False, vars=None, fallback=_UNSET)
Like get(), but convert value to an integer.
getfloat(section, options, raw=False, vars=None, fallback=_UNSET)
Like get(), but convert value to a float.
getboolean(section, options, raw=False, vars=None, fallback=_UNSET)
Like get(), but convert value to a boolean (currently case
insensitively defined as 0, false, no, off for False, and 1, true,
yes, on for True). Returns False or True.
items(section=_UNSET, raw=False, vars=None)
If section is given, return a list of tuples with (name, value) for
each option in the section. Otherwise, return a list of tuples with
(section_name, section_proxy) for each section, including DEFAULTSECT.
remove_section(section)
Remove the given file section and all its options.
remove_option(section, option)
Remove the given option from the given section.
set(section, option, value)
Set the given option.
write(fp, space_around_delimiters=True)
Write the configuration state in .ini format. If
`space_around_delimiters' is True (the default), delimiters
between keys and values are surrounded by spaces.
"""
from collections.abc import MutableMapping
from collections import OrderedDict as _default_dict, ChainMap as _ChainMap
import functools
import io
import itertools
import re
import sys
import warnings
__all__ = ["NoSectionError", "DuplicateOptionError", "DuplicateSectionError",
"NoOptionError", "InterpolationError", "InterpolationDepthError",
"InterpolationSyntaxError", "ParsingError",
"MissingSectionHeaderError",
"ConfigParser", "SafeConfigParser", "RawConfigParser",
"DEFAULTSECT", "MAX_INTERPOLATION_DEPTH"]
DEFAULTSECT = "DEFAULT"
MAX_INTERPOLATION_DEPTH = 10
# exception classes
class Error(Exception):
"""Base class for ConfigParser exceptions."""
def __init__(self, msg=''):
self.message = msg
Exception.__init__(self, msg)
def __repr__(self):
return self.message
__str__ = __repr__
class NoSectionError(Error):
"""Raised when no section matches a requested option."""
def __init__(self, section):
Error.__init__(self, 'No section: %r' % (section,))
self.section = section
self.args = (section, )
class DuplicateSectionError(Error):
"""Raised when a section is repeated in an input source.
Possible repetitions that raise this exception are: multiple creation
using the API or in strict parsers when a section is found more than once
in a single input file, string or dictionary.
"""
def __init__(self, section, source=None, lineno=None):
msg = [repr(section), " already exists"]
if source is not None:
message = ["While reading from ", repr(source)]
if lineno is not None:
message.append(" [line {0:2d}]".format(lineno))
message.append(": section ")
message.extend(msg)
msg = message
else:
msg.insert(0, "Section ")
Error.__init__(self, "".join(msg))
self.section = section
self.source = source
self.lineno = lineno
self.args = (section, source, lineno)
class DuplicateOptionError(Error):
"""Raised by strict parsers when an option is repeated in an input source.
Current implementation raises this exception only when an option is found
more than once in a single file, string or dictionary.
"""
def __init__(self, section, option, source=None, lineno=None):
msg = [repr(option), " in section ", repr(section),
" already exists"]
if source is not None:
message = ["While reading from ", repr(source)]
if lineno is not None:
message.append(" [line {0:2d}]".format(lineno))
message.append(": option ")
message.extend(msg)
msg = message
else:
msg.insert(0, "Option ")
Error.__init__(self, "".join(msg))
self.section = section
self.option = option
self.source = source
self.lineno = lineno
self.args = (section, option, source, lineno)
class NoOpti
|
nhtdata/pystrix
|
pystrix/ami/dahdi.py
|
Python
|
gpl-3.0
| 3,238
| 0.004941
|
"""
pystrix.ami.dahdi
=================
Provides classes meant to be fed to a `Manager` instance's `send_action()` function.
Specifically, this module provides implementations for features specific to the DAHDI technology.
Legal
-----
This file is part of pystrix.
pystrix is free software; you can redistribute it and/or modify
it und
|
er the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU
|
General Public License and
GNU Lesser General Public License along with this program. If not, see
<http://www.gnu.org/licenses/>.
(C) Ivrnet, inc., 2011
Authors:
- Neil Tallim <[email protected]>
The requests implemented by this module follow the definitions provided by
https://wiki.asterisk.org/
"""
from ami import (_Request, ManagerError)
import dahdi_events
import generic_transforms
class DAHDIDNDoff(_Request):
"""
Sets a DAHDI channel's DND status to off.
"""
def __init__(self, dahdi_channel):
"""
`dahdi_channel` is the channel to modify.
"""
_Request.__init__(self, 'DAHDIDNDoff')
self['DAHDIChannel'] = dahdi_channel
class DAHDIDNDon(_Request):
"""
Sets a DAHDI channel's DND status to on.
"""
def __init__(self, dahdi_channel):
"""
`dahdi_channel` is the channel to modify.
"""
_Request.__init__(self, 'DAHDIDNDon')
self['DAHDIChannel'] = dahdi_channel
class DAHDIDialOffhook(_Request):
"""
Dials a number on an off-hook DAHDI channel.
"""
def __init__(self, dahdi_channel, number):
"""
`dahdi_channel` is the channel to use and `number` is the number to dial.
"""
_Request.__init__(self, 'DAHDIDialOffhook')
self['DAHDIChannel'] = dahdi_channel
self['Number'] = number
class DAHDIHangup(_Request):
"""
Hangs up a DAHDI channel.
"""
def __init__(self, dahdi_channel):
"""
`dahdi_channel` is the channel to hang up.
"""
_Request.__init__(self, 'DAHDIHangup')
self['DAHDIChannel'] = dahdi_channel
class DAHDIRestart(_Request):
"""
Fully restarts all DAHDI channels.
"""
def __init__(self):
_Request.__init__(self, 'DAHDIRestart')
class DAHDIShowChannels(_Request):
"""
Provides the current status of all (or one) DAHDI channels through a series of
'DAHDIShowChannels' events, ending with a 'DAHDIShowChannelsComplete' event.
"""
_aggregates = (dahdi_events.DAHDIShowChannels_Aggregate,)
_synchronous_events_list = (dahdi_events.DAHDIShowChannels,)
_synchronous_events_finalising = (dahdi_events.DAHDIShowChannelsComplete,)
def __init__(self, dahdi_channel=None):
_Request.__init__(self, 'DAHDIShowChannels')
if not dahdi_channel is None:
self['DAHDIChannel'] = dahdi_channel
|
Locottus/Python
|
machines/python/stepperLeft.py
|
Python
|
mit
| 1,515
| 0.031023
|
import RPi.GPIO as GPIO
import time
from array import *
#configuracoin de pines del stepper bipolar
out1 = 11
out2 = 13
out3 = 15
out4 = 16
#delay value
timeValue = 0.005
#matriz de pines del stepper
outs = [out1,out2,out3,out4]
#secuencia para mover el stepper
matriz = [
[1,0,0,1],
[1,1,0,0],
[0,1,1,0],
[0,0,1,1],
]
#seteo de pines
GPIO.setmode(GPIO.BOARD)
for o in outs:
GPIO.setup(o,GPIO.OUT)
def wakeupMotor():
for o in outs:
GPIO.output(o,GPIO.HIGH)
def sleepMotor():
for
|
o in outs:
GPIO.output(o,GPIO.LOW)
|
def setMatrizPins(pin,valor):
if (valor == 0):
GPIO.output(outs[pin],GPIO.LOW)
if (valor == 1):
GPIO.output(outs[pin],GPIO.HIGH)
def runForward():
i = 0
while (i < 4):
#print(matriz[i][0],matriz[i][1],matriz[i][2],matriz[i][3])
setMatrizPins(0,matriz[i][0])
setMatrizPins(1,matriz[i][1])
setMatrizPins(2,matriz[i][2])
setMatrizPins(3,matriz[i][3])
i = i + 1
time.sleep(timeValue)
def runBackwards():
i = 3
while (i >=0):
#print(matriz[i][0],matriz[i][1],matriz[i][2],matriz[i][3])
setMatrizPins(0,matriz[i][0])
setMatrizPins(1,matriz[i][1])
setMatrizPins(2,matriz[i][2])
setMatrizPins(3,matriz[i][3])
i = i - 1
time.sleep(timeValue)
#void main()
print('starting stepper')
for x in range(500):
runBackwards()
print(x)
sleepMotor()
GPIO.cleanup()
|
Som-Energia/invoice-janitor
|
invoicing/f1fixing/import_error/errors.py
|
Python
|
agpl-3.0
| 15,081
| 0.006366
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import dateutil.parser
from models import F1ImportError, \
LectPool, \
codigoOrigen_to_O, \
O_to_codigoOrigen
IMP_ERRORS = {}
def register(cls_error):
name = cls_error.__name__
if name in IMP_ERRORS.keys():
return True
else:
IMP_ERRORS[name] = cls_error
class ImpError(object):
priority = None
@classmethod
def check(cls, O, e):
pass
def __init__(self, O, e):
self.O = O
self.e = e
def fix(self):
pass
def done(self):
pass
def __gt__(self, other):
return self.priority > other.piority
def __lt__(self, other):
return self.priority < other.piority
def __ge__(self, other):
return self.priority >= other.piority
def __le__(self, other):
return self.priority <= other.piority
class SmallDiffError(ImpError):
description = 'ERROR: Difference between abs(XML-DB) > 2.0'
priority = 1
exit = True
invoicing = False
max_diff = 2.0
@classmethod
def check(cls, O, e):
if e.error.tipus not in ['A', 'R']:
return False
diff = e.error.valor_xml-e.error.valor_db
if abs(diff) < cls.max_diff:
return True
return False
def fix(self):
e = self.e
O = self.O
filename = os.path.join('/tmp', e.name)
e.F1.dump(filename)
e.update_xml_attribute('Lectura')
e.reload(update=True)
return e
register(SmallDiffError)
class UnionFenosa0measError(ImpError):
description = 'Union Fenosa NULL measurement'
priority = 2
exit = True
invoicing = False
@classmethod
def check(cls, O, e):
uf_id = O.ResPartner.search([('name', '=', 'UNIÓN FENOSA DISTRIBUCIÓN S.A.')])[0]
return e.polissa.distribuidora[0] == uf_id and e.error.valor_xml == 0
def fix(self):
e = self.e
O = self.O
exception_tag = "Union Fenosa fix"
if e.polissa.tarifa not in ['2.0A', '2.1']:
raise Exception('{exception_tag}: DHA and >15kW not handled'.format(**locals()))
if len(e.F1.root.Facturas.FacturaATR) > 1:
raise Exception('{exception_tag}: Factura with multiple FacturaATR'.format(**locals()))
TerminoEnergiaActiva = e.F1.root.Facturas.FacturaATR.EnergiaActiva.TerminoEnergiaActiva
consumption = None
# TODO: Check whethet there's any later invoice
for TerminoEnergiaActiva_ in TerminoEnergiaActiva:
if TerminoEnergiaActiva.FechaDesd
|
e == e.error.data or TerminoEnergiaActiva.FechaHasta == e.error.data:
consumption = TerminoEnergiaActiva.Periodo[0].ValorEnergiaActiva
break
if not consumption:
raise Exception('{exception_tag}: Consumption not found'.format(**locals()))
if len(e.F1.root.Fact
|
uras.FacturaATR) > 1 or len(e.F1.root.Facturas.FacturaATR.Medidas) > 1 :
raise Exception('{exception_tag}: Factura with multiple FacturaATR or Medidas'.format(**locals()))
# Backup
filename = os.path.join('/tmp', e.name)
e.F1.dump(filename)
for idx_ap, Aparato in enumerate(e.F1.root.Facturas.FacturaATR.Medidas.Aparato):
if (Aparato.Tipo in ['CC', 'CA', 'P']) and (Aparato.CodigoDH == 1):
for idx_int, Integrador in enumerate(Aparato.Integrador):
if not (Integrador.Magnitud == 'AE' or Integrador.CodigoPeriodo == '10'):
continue
if not Integrador.ConsumoCalculado == consumption:
raise Exception('{exception_tag}: Integrador and factura doesn\'t match'.format(**locals()))
DesdeFechaHora = dateutil.parser.parse(
str(Integrador.LecturaDesde.FechaHora)).date().strftime('%Y-%m-%d')
HastaFechaHora = dateutil.parser.parse(
str(Integrador.LecturaHasta.FechaHora)).date().strftime('%Y-%m-%d')
if (DesdeFechaHora == e.error.data and
((Integrador.LecturaDesde.Lectura == 0) and (Integrador.LecturaHasta.Lectura == 0))):
Integrador.LecturaDesde.Lectura = e.error.valor_db
Integrador.LecturaHasta.Lectura = e.error.valor_db + consumption
e.reload(update=True)
fields_to_search = [('comptador.polissa', '=', e.polissa.id[0]),
('name', 'in', [DesdeFechaHora, HastaFechaHora]),
('lectura', '=', e.error.valor_db + consumption )]
lect_pool_ids = O.GiscedataLecturesLecturaPool.search(fields_to_search)
if not len(lect_pool_ids) > 0:
raise Exception('{exception_tag}: Failed updating lectura'.format(**locals()))
elif (HastaFechaHora == e.error.data and
((Integrador.LecturaDesde.Lectura == 0) and (Integrador.LecturaHasta.Lectura == 0))):
fields_to_search = [('comptador.polissa', '=', e.polissa.id[0]),
('name', '=',DesdeFechaHora)]
lect_pool_ids = O.GiscedataLecturesLecturaPool.search(fields_to_search)
if len(lect_pool_ids) != 1:
raise Exception('{exception_tag}: Failed updating lectura'.format(**locals()))
Integrador.LecturaDesde.Lectura = e.error.valor_db
Integrador.LecturaHasta.Lectura = e.error.valor_db + consumption
e.reload(update=True)
fields_to_search = [('comptador.polissa', '=', e.polissa.id[0]),
('name', 'in', [DesdeFechaHora, HastaFechaHora]),
('lectura', '=', e.error.valor_db + consumption )]
lect_pool_ids = O.GiscedataLecturesLecturaPool.search(fields_to_search)
if not len(lect_pool_ids) > 0:
raise Exception('{exception_tag}: Failed updating lectura'.format(**locals()))
lect_pool = LectPool(O, lect_pool_ids[0])
lect_pool.update_observacions('R. 0 Estimada a partir de consum F1 (ABr)')
return
raise Exception('{exception_tag}: Scenario not found'.format(**locals()))
register(UnionFenosa0measError)
class StartOfContractError(ImpError):
description = 'WARNING: ** Contract- First Measure **'
priority = 3
exit = True
invoicing = False
@classmethod
def check(cls, O, e):
return e.error.data == e.polissa.data_alta
register(StartOfContractError)
class EndOfContractError(ImpError):
description = 'WARNING: ** Contract- Last measure **'
priority = 4
exit = False
invoicing = True
@classmethod
def check(cls, O, e):
return e.error.data == e.polissa.data_baixa
register(EndOfContractError)
class StartOfMeterError(ImpError):
description = 'WARNING: ** Meter- First measure **'
priority = 5
exit = True
invoicing = False
@classmethod
def check(cls, O, e):
fields_to_search = [('polissa', '=', e.polissa.id), ('name', '=', e.error.comptador)]
comptador_ids = O.GiscedataLecturesComptador.search(fields_to_search, 0, 0, False, {'active_test': False})
if len(comptador_ids) == 0:
raise Exception('Comptador missing')
comptador_id = comptador_ids[0]
fields_to_search = [('comptador', '=', comptador_id)]
lect_pool_id = sorted(O.GiscedataLecturesLecturaPool.search(fields_to_search))[0]
fields_to_read = ['name']
fields_to_read = ['name']
return e.error.data == O.GiscedataLecturesLecturaPool.read(lect_pool_id, fields_to_read)['name']
register(StartOfMeterError)
class EndOfMeterError(ImpError):
description = 'WARNING: ** Meter - Last measure **'
|
crunchy-github/python-notifier
|
notifier/dispatch.py
|
Python
|
lgpl-2.1
| 2,535
| 0.015792
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Author: Andreas Büsching <[email protected]>
#
# a generic dispatcher implementation
#
# Copyright (C) 2006, 2007, 2009, 2010
# Andreas Büsching <[email protected]>
#
# This library is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License version
# 2.1 as published by the Free Software Foundation.
#
# This library is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301 USA
"""generic implementation of external dispatchers, integratable into
several notifiers."""
# required for dispatcher use
MIN_TIMER = 100
__dispatchers = {}
__dispatchers[True] = []
__dispatchers[False] = []
def dispatcher_add(method, min_timeout=True):
"""The notifier supports external dispatcher functions that will be
called within each scheduler step. This functionality may be useful
for applications having an own event mechanism that needs to be
triggered as often as possible. This method registers a new
dispatcher function. To ensure that the notifier loop does not
suspend to long in the sleep state during the poll a minimal timer
MIN_TIMER is set to guarantee that the dispatcher functions are
called at least every MIN_TIMER milliseconds."""
global __dispatchers, MIN_TIMER
__dispatchers[min_timeout].append(method)
if __dispatchers[True]:
return MIN_TIMER
else:
return None
def dispatcher_remove(method):
"""Removes an external dispatcher function from the list"""
global __dispatchers, MIN_TIMER
for val in (True, False):
if method in __dispatchers[val]:
__dispatchers[val].remove(method)
break
if __dispatchers[True]:
return MIN_TIMER
else:
return None
def dispatcher_run():
"""Invokes all registered dispatcher functions"""
global __dispatchers
for val in (True, False):
# there is no need to copy an empty dict
|
if not __dispatchers[val]:
continue
for
|
disp in __dispatchers[val][:]:
if not disp():
dispatcher_remove(disp)
if __dispatchers[True]:
return MIN_TIMER
else:
return None
def dispatcher_count():
global __dispatchers
return len(__dispatchers)
|
amadeusproject/amadeuslms
|
subjects/migrations/0013_auto_20170120_1610.py
|
Python
|
gpl-2.0
| 503
| 0.001988
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10 on 2017-01-20 19:10
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('subjects', '0012_auto_20170112_1408'),
]
operations = [
migrations.AlterField(
model_name='subject',
name='tags',
field=models.ManyToManyField(blank=True, null=True, to='subjects.Tag', ve
|
rbose_na
|
me='tags'),
),
]
|
ares/robottelo
|
tests/foreman/cli/test_template.py
|
Python
|
gpl-3.0
| 8,063
| 0
|
# -*- encoding: utf-8 -*-
"""Test class for Template CLI
:Requirement: Template
:CaseAutomation: Automated
:CaseLevel: Acceptance
:CaseComponent: CLI
:TestType: Functional
:CaseImportance: High
:Upstream: No
"""
from fauxfactory import gen_string
from robottelo.cli.base import CLIReturnCodeError
from robottelo.cli.factory import (
make_location,
make_org,
make_os,
make_template,
make_user,
)
from robottelo.cli.template import Template
from robottelo.cli.user import User
from robottelo.decorators import run_only_on, skip_if_bug_open, tier1, tier2
from robottelo.test import CLITestCase
class TemplateTestCase(CLITestCase):
"""Test class for Config Template CLI."""
@run_only_on('sat')
@tier1
def test_positive_create_with_name(self):
"""Check if Template can be created
:id: 77deaae8-447b-47cc-8af3-8b17476c905f
:expectedresults: Template is created
:CaseImportance: Critical
"""
name = gen_string('alpha')
template = make_template({'name': name})
self.assertEqual(template['name'], name)
@run_only_on('sat')
@tier1
def test_positive_update_name(self):
"""Check if Template can be updated
:id: 99bdab7b-1279-4349-a655-4294395ecbe1
:expectedresults: Template is updated
:CaseImportance: Critical
"""
template = make_template()
updated_name = gen_string('alpha')
Template.update({
'id': template['id'],
'name': updated_name,
})
template = Template.info({'id': template['id']})
self.assertEqual(updated_name, template['name'])
@tier1
def test_positive_update_with_manager_role(self):
"""Create template providing the initial name, then update its name
with manager user role.
:id: 28c4357a-93cb-4b01-a445-5db50435bcc0
:expectedresults: Provisioning Template is created, and its name can
be updated.
:CaseImportance: Critical
:BZ: 1277308
"""
new_name = gen_string('alpha')
username = gen_string('alpha')
password = gen_string('alpha')
org = make_org()
loc = make_location()
template = make_template({
'organization-ids': org['id'], 'location-ids': loc['id']})
# Create user with Manager role
user = make_user({
'login': username,
'password': password,
'admin': False,
'organization-ids': org['id'],
'location-ids': loc['id'],
})
User.add_role({'id': user['id'], 'role': "Manager"})
# Update template name with that user
Template.with_user(username=username, password=password).update({
'id': template['id'], 'name': new_name})
template = Template.info({'id': template['id']})
self.assertEqual(new_name, template['name'])
@run_only_on('sat')
@tier1
def test_positive_create_with_loc(self):
"""Check if Template with Location can be created
:id: 263aba0e-4f54-4227-af97-f4bc8f5c0788
:expectedresults: Template is created and new Location has been
assigned
:CaseImportance: Critical
"""
new_loc = make_location()
new_template = make_template({'location-ids': new_loc['id']})
self.assertIn(new_loc['name'], new_template['locations'])
@run_only_on('sat')
@tier1
def test_positive_create_locked(self):
"""Check that locked Template can be created
:id: ff10e369-85c6-45f3-9cda-7e1c17a6632d
:expectedresults: The locked template is created successfully
:CaseImportance: Critical
"""
new_template = make_template({
'locked': 'true',
'name': gen_string('alpha'),
})
self.assertEqual(new_template['locked'], 'yes')
@run_only_on('sat')
@tier1
def test_positive_create_with_org(self):
"""Check if Template with Organization can be created
:id: 5de5ca76-1a39-46ac-8dd4-5d41b4b49076
:expectedresults: Template is created and new Organization has been
assigned
:CaseImportance: Critical
"""
new_org = make_org()
new_template = make_template({
'name': gen_string('alpha'),
'organization-ids': new_org['id'],
})
self.assertIn(new_org['name'], new_template['organizations'])
@run_only_on('sat')
@tier2
def test_positive_add_os_by_id(self):
"""Check if operating system can be added to a template
:id: d9f481b3-9757-4208-b451-baf4792d4d70
:expectedresults: Operating system is added to the template
:CaseLevel: Integration
"""
new_template = make_template()
new_os = make_os()
Template.add_operatingsystem({
'id': new_template['id'],
'operatingsystem-id': new_os['id'],
})
new_template = Template.info({'id': new_template['id']})
os_string = '{0} {1}.{2}'.format(
new_os['name'], new_os['major-version'], new_os['minor-version'])
self.assertIn(os_string, new_template['operating-systems'])
@run_only_on('sat')
@skip_if_bug_open('bugzilla', 1395229)
@tier2
def test_positive_remove_os_by_id(self):
"""Check
|
if operating system can be removed from a template
:id: b5362565-6dce-4770-81e1-4fe3ec
|
6f6cee
:expectedresults: Operating system is removed from template
:CaseLevel: Integration
"""
template = make_template()
new_os = make_os()
Template.add_operatingsystem({
'id': template['id'],
'operatingsystem-id': new_os['id'],
})
template = Template.info({'id': template['id']})
os_string = '{0} {1}.{2}'.format(
new_os['name'], new_os['major-version'], new_os['minor-version']
)
self.assertIn(os_string, template['operating-systems'])
Template.remove_operatingsystem({
'id': template['id'],
'operatingsystem-id': new_os['id']
})
template = Template.info({'id': template['id']})
self.assertNotIn(os_string, template['operating-systems'])
@run_only_on('sat')
@tier1
def test_positive_create_with_content(self):
"""Check if Template can be created with specific content
:id: 0fcfc46d-5e97-4451-936a-e8684acac275
:expectedresults: Template is created with specific content
:CaseImportance: Critical
"""
content = gen_string('alpha')
name = gen_string('alpha')
template = make_template({
'content': content,
'name': name,
})
self.assertEqual(template['name'], name)
template_content = Template.dump({'id': template['id']})
self.assertIn(content, template_content[0])
@run_only_on('sat')
@tier1
def test_positive_delete_by_id(self):
"""Check if Template can be deleted
:id: 8e5245ee-13dd-44d4-8111-d4382cacf005
:expectedresults: Template is deleted
:CaseImportance: Critical
"""
template = make_template()
Template.delete({'id': template['id']})
with self.assertRaises(CLIReturnCodeError):
Template.info({'id': template['id']})
@run_only_on('sat')
@tier2
def test_positive_clone(self):
"""Assure ability to clone a provisioning template
:id: 27d69c1e-0d83-4b99-8a3c-4f1bdec3d261
:expectedresults: The template is cloned successfully
:CaseLevel: Integration
"""
cloned_template_name = gen_string('alpha')
template = make_template()
result = Template.clone({
'id': template['id'],
'new-name': cloned_template_name,
})
new_template = Template.info({'id': result[0]['id']})
self.assertEqual(new_template['name'], cloned_template_name)
|
nagyistoce/netzob
|
src/netzob/Common/MMSTD/Dictionary/Memory.py
|
Python
|
gpl-3.0
| 8,119
| 0.006285
|
# -*- coding: utf-8 -*-
#+---------------------------------------------------------------------------+
#| 01001110 01100101 01110100 01111010 01101111 01100010 |
#| |
#| Netzob : Inferring communication protocols |
#+---------------------------------------------------------------------------+
#| Copyright (C) 2011 Georges Bossert and Frédéric Guihéry |
#| This program is free software: you can redistribute it and/or modify |
#| it under the terms of the GNU General Public License as published by |
#| the Free Software Foundation, either version 3 of the License, or |
#| (at your option) any later version. |
#| |
#| This program is distributed in the hope that it will be useful, |
#| but WITHOUT ANY WARRANTY; without even the implied warranty of |
#| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
#| GNU General Public License for more details. |
#| |
#| You should have received a copy of the GNU General Public License |
#| along with this program. If not, see <http://www.gnu.org/licenses/>. |
#+---------------------------------------------------------------------------+
#| @url : http://www.netzob.org |
#| @contact : [email protected] |
#| @sponsors : Amossys, http://www.amossys.fr |
#| Supélec, http://www.rennes.supelec.fr/ren/rd/cidre/ |
#+---------------------------------------------------------------------------+
#+---------------------------------------------------------------------------+
#| Standard library imports |
#+---------------------------------------------------------------------------+
import logging
from netzob.Common.Type.TypeConvertor import TypeConvertor
#+---------------------------------------------------------------------------+
#| Related third party imports |
#+---------------------------------------------------------------------------+
#+---------------------------------------------------------------------------+
#| Local application imports |
#+---------------------------------------------------------------------------+
class Memory():
"""Memory:
Definition of a memory, used to store variable values in a persisting and independent way.
"""
def __init__(self):
|
"""Constructor of Memory:
"""
# create logger with the given configuration
self.log = logging.getLogger('netzob.Common.MMSTD.Dictionary.Memory.py')
self.memory = dict()
self.temporaryMemory = dict()
self.memory_acces_cb = None
def setMemoryAccess_cb(self, cb):
"""Set the callback to execute after
|
a memory access"""
self.memory_acces_cb = cb
def duplicate(self):
"""Duplicates in a new memory"""
duplicatedMemory = Memory()
for k in self.memory.keys():
duplicatedMemory.memory[k] = self.memory[k]
duplicatedMemory.createMemory()
return duplicatedMemory
#+---------------------------------------------------------------------------+
#| Functions on memories |
#+---------------------------------------------------------------------------+
def createMemory(self):
"""createMemory:
Reinit the temporary memory and copy all values from the real memory in it.
"""
self.temporaryMemory = dict()
for key in self.memory.keys():
self.temporaryMemory[key] = self.memory[key]
def persistMemory(self):
"""persistMemory:
Copy all values from the temporary memory into the real memory.
"""
self.memory = dict()
for key in self.temporaryMemory.keys():
self.memory[key] = self.temporaryMemory[key]
def cleanMemory(self):
"""cleanMemory:
Remove all variables and values from real and temporary memories.
"""
# self.memory = dict() # TODO: impement this change in all calling functions.
self.temporaryMemory = dict()
def recallMemory(self):
"""recallMemory:
Return all values store in the temporary memory.
@return: the value of all variables in the temporary memory.
"""
return self.temporaryMemory
def printMemory(self):
"""printMemory:
Debug functions which print all values in temporary memory.
"""
self.log.debug("Memory map:")
for _id in self.temporaryMemory.keys():
self.log.debug("> " + str(_id) + " = " + str(self.temporaryMemory.get(_id)))
#+---------------------------------------------------------------------------+
#| Functions on temporary memory elements |
#+---------------------------------------------------------------------------+
def hasMemorized(self, variable):
"""hasMemorized:
Check if a variable is in the temporary memory.
@param variable: the given variable we search in memory.
@return: True if the variable has been found in the memory.
"""
return variable.getID() in self.temporaryMemory.keys()
def restore(self, variable):
"""restore:
Copy back the value of a variable from the real memory in the temporary memory.
@param variable: the given variable, the value of which we want to restore.
"""
if variable.getID() in self.memory.keys():
self.temporaryMemory[variable.getID()] = self.memory[variable.getID()]
if self.memory_acces_cb is not None:
value = variable.getCurrentValue()
if value is not None:
value = TypeConvertor.bin2strhex(value)
self.memory_acces_cb("W", variable, value)
def memorize(self, variable):
"""memorize:
Save the current value of a variable in memory.
@param variable: the given variable, the value of which we want to save.
"""
if variable.getCurrentValue() is not None:
self.temporaryMemory[variable.getID()] = variable.getCurrentValue()
if self.memory_acces_cb is not None:
value = variable.getCurrentValue()
if value is not None:
value = TypeConvertor.bin2strhex(value)
self.memory_acces_cb("W", variable, value)
def forget(self, variable):
"""forget:
Remove a variable and its value from the temporary memory.
"""
if self.hasMemorized(variable):
self.temporaryMemory.remove(variable.getID())
if self.memory_acces_cb is not None:
self.memory_acces_cb("D", variable, None)
def recall(self, variable):
"""recall:
Return the value of one variable store in the temporary memory.
@param variable: the variable, the value of which we are searching.
@return: the value of the given variable in the temporary memory.
"""
if self.hasMemorized(variable):
if self.memory_acces_cb is not None:
value = self.temporaryMemory[variable.getID()]
if value is not None:
value = TypeConvertor.bin2strhex(value)
self.memory_acces_cb("R", variable, value)
return self.temporaryMemory[variable.getID()]
else:
return None
|
Injabie3/lui-cogs
|
welcome/welcome.py
|
Python
|
gpl-3.0
| 20,055
| 0.005335
|
"""Welcome cog
Sends welcome DMs to users that join the server.
"""
import os
import logging
import discord
from discord.ext import commands
from __main__ import send_cmd_help # pylint: disable=no-name-in-module
from cogs.utils.dataIO import dataIO
# Requires checks utility from:
# https://github.com/Rapptz/RoboDanny/tree/master/cogs/utils
from cogs.utils import checks
#Global variables
DEFAULT_MESSAGE = "Welcome to the server! Hope you enjoy your stay!"
DEFAULT_TITLE = "Welcome!"
LOGGER = None
SAVE_FOLDER = "data/lui-cogs/welcome/" #Path to save folder.
SAVE_FILE = "settings.json"
def checkFolder():
"""Used to create the data folder at first startup"""
if not os.path.exists(SAVE_FOLDER):
print("Creating " + SAVE_FOLDER + " folder...")
os.makedirs(SAVE_FOLDER)
def checkFiles():
"""Used to initialize an empty database at first startup"""
theFile = SAVE_FOLDER + SAVE_FILE
if not dataIO.is_valid_json(theFile):
print("Creating default welcome settings.json...")
dataIO.save_json(theFile, {})
class Welcome: # pylint: disable=too-many-instance-attributes
"""Send a welcome DM on server join."""
def loadSettings(self):
"""Loads settings from the JSON file"""
self.settings = dataIO.load_json(SAVE_FOLDER+SAVE_FILE)
def saveSettings(self):
"""Loads settings from the JSON file"""
dataIO.save_json(SAVE_FOLDER+SAVE_FILE, self.settings)
#Class constructor
def __init__(self, bot):
self.bot = bot
#The JSON keys for the settings:
self.keyWelcomeDMEnabled = "welcomeDMEnabled"
self.keyWelcomeLogEnabled = "welcomeLogEnabled"
self.keyWelcomeLogChannel = "welcomeLogChannel"
self.keyWelcomeTitle = "welcomeTitle"
self.keyWelcomeMessage = "welcomeMessage"
self.keyWelcomeImage = "welcomeImage"
self.keyLeaveLogEnabled = "leaveLogEnabled"
self.keyLeaveLogChannel = "leaveLogChannel"
checkFolder()
checkFiles()
self.loadSettings()
#The async function that is triggered on new member join.
async def sendWelcomeMessage(self, newUser, test=False):
"""Sends the welcome message in DM."""
serverId = newUser.server.id
#Do not send DM if it is disabled!
if not self.settings[serverId][self.keyWelcomeDMEnabled]:
return
try:
welcomeEmbed = discord.Embed(title=self.settings[serverId][self.keyWelcomeTitle])
welcomeEmbed.description = self.settings[serverId][self.keyWelcomeMessage]
welcomeEmbed.colour = discord.Colour.red()
if self.keyWelcomeImage in self.settings[serverId].keys() and \
self.settings[serverId][self.keyWelcomeImage]:
imageUrl = self.settings[serverId][self.keyWelcomeImage]
welcomeEmbed.set_image(url=imageUrl.replace(" ", "%20"))
await self.bot.send_message(newUser, embed=welcomeEmbed)
except (discord.Forbidden, discord.HTTPException) as errorMsg:
LOGGER.error("Could not send message, the user may have"
"turned off DM's from this server."
" Also, make sure the server has a title "
"and message set!", exc_info=True)
LOGGER.error(errorMsg)
if self.settings[serverId][self.keyWelcomeLogEnabled] and not test:
channel = self.bot.get_channel(self.settings[serverId][self.keyWelcomeLogChannel])
await self.bot.send_message(channel,
":bangbang: ``Server Welcome:`` User "
"{0.name}#{0.discriminator} ({0.id}) has"
" joined. Could not send DM!".format(
newUser))
await self.bot.send_message(channel, errorMsg)
else:
if self.settings[serverId][self.keyWelcomeLogEnabled] and not test:
channel = self.bot.get_channel(self.settings[serverId][self.keyWelcomeLogChannel])
await self.bot.send_message(channel,
":o: ``Server Welcome:`` User {0.name}#"
"{0.discriminator} ({0.id}) has joined. "
"DM sent.".format(newUser))
LOGGER.info("User %s#%s (%s) has joined. DM sent.",
newUser.name,
newUser.discriminator,
newUser.id)
async def logServerLeave(self, leaveUser):
"""Logs the server leave to a channel, if enabled."""
serverId = leaveUser.server.id
if self.settings[serverId][self.keyLeaveLogEnabled]:
channel = self.bot.get_channel(self.settings[serverId][self.keyLeaveLogChannel])
await self.bot.send_message(channel,
":x: ``Server Leave :`` User {0.name}#"
"{0.discriminator} ({0.id}) has left the "
"server.".format(leaveUser))
LOGGER.info("User %s#%s (%s) has left the server.",
leaveUser.name,
leaveUser.discriminator,
leaveUser.id)
####################
# MESSAGE COMMANDS #
####################
#[p]welcome
@commands.group(name="welcome", pass_context=True, no_pm=False)
@checks.serverowner() #Only allow server owner to execute the following command.
async def _welcome(self, ctx):
"""Server welcome message settings."""
if ctx.invoked_subcommand is None:
await send_cmd_help(ctx)
#[p]welcome setmessage
@_welcome.command(pass_context=True, no_pm=False)
@checks.serverowner() #Only allow server owner to execute the following command.
async def setmessage(self, ctx):
"""Interactively configure the contents of the welcome DM."""
await se
|
lf.bot.say("What would you like the welcome DM message to be?")
message = await self.bot.wait_for_message(timeout=60,
|
author=ctx.message.author,
channel=ctx.message.channel)
if message is None:
await self.bot.say("No response received, not setting anything!")
return
if len(message.content) > 2048:
await self.bot.say("Your message is too long!")
return
try:
self.loadSettings()
if ctx.message.author.server.id in self.settings:
self.settings[ctx.message.author.server.id] \
[self.keyWelcomeMessage] = message.content
else:
self.settings[ctx.message.author.server.id] = {}
self.settings[ctx.message.author.server.id] \
[self.keyWelcomeMessage] = message.content
self.saveSettings()
except Exception as errorMsg: # pylint: disable=broad-except
await self.bot.say("Could not save settings! Check the console for "
"details.")
print(errorMsg)
else:
await self.bot.say("Message set to:")
await self.bot.say("```" + message.content + "```")
LOGGER.info("Message changed by %s#%s (%s)",
ctx.message.author.name,
ctx.message.author.discriminator,
ctx.message.author.id)
LOGGER.info(message.content)
#[p]welcome toggledm
@_welcome.command(pass_context=True, no_pm=False)
@checks.serverowner() #Only allow server owner to execute the following command.
async def toggledm(self, ctx):
"""Toggle sending a welcome DM."""
self.load
|
Johnetordoff/osf.io
|
api_tests/nodes/views/test_node_children_list.py
|
Python
|
apache-2.0
| 30,028
| 0.001599
|
import pytest
from api.base.settings.defaults import API_BASE
from framework.auth.core import Auth
from osf.models import AbstractNode, NodeLog
from osf.utils import permissions
from osf.utils.sanitize import strip_html
from osf_tests.factories import (
NodeFactory,
ProjectFactory,
OSFGroupFactory,
RegistrationFactory,
AuthUserFactory,
PrivateLinkFactory,
)
from tests.base import fake
@pytest.fixture()
def user():
return AuthUserFactory()
@pytest.mark.django_db
class TestNodeChildrenList:
@pytest.fixture()
def private_project(self, user):
private_project = ProjectFactory()
private_project.add_contributor(
user,
permissions=permissions.WRITE
)
private_project.save()
return private_project
@pytest.fixture()
def component(self, user, private_project):
return NodeFactory(parent=private_project, creator=user)
@pytest.fixture()
def pointer(self):
return ProjectFactory()
@pytest.fixture()
def private_project_url(self, private_project):
return '/{}nodes/{}/children/'.format(API_BASE, private_project._id)
@pytest.fixture()
def public_project(self, user):
return ProjectFactory(is_public=True, creator=user)
@pytest.fixture()
def public_component(self, user, public_project):
return NodeFactory(parent=public_project, creator=user, is_public=True)
@pytest.fixture()
def public_project_url(self, user, public_project):
return '/{}nodes/{}/children/'.format(API_BASE, public_project._id)
@pytest.fixture()
def view_only_link(self, private_project):
view_only_link = PrivateLinkFactory(name='node_view_only_link')
view_only_link.nodes.add(private_project)
view_only_link.save()
return view_only_link
def test_return_public_node_children_list(
self, app, public_component,
public_project_url):
# test_return_public_node_children_list_logged_out
res = app.get(public_project_url)
assert res.status_code == 200
assert res.content_type == 'application/vnd.api+json'
assert len(res.json['data']) == 1
assert res.json['data'][0]['id'] == public_component._id
# test_return_public_node_children_list_logged_in
non_contrib = AuthUserFactory()
res = app.get(public_project_url, auth=non_contrib.auth)
assert res.status_code == 200
assert res.content_type == 'application/vnd.api+json'
assert len(res.json['data']) == 1
assert res.json['data'][0]['id'] == public_component._id
def test_return_private_node_children_list(
self, app, user, component, private_project, private_project_url):
# test_return_private_node_children_list_logged_out
res = app.get(private_project_url, expect_errors=True)
assert res.status_code == 401
assert 'detail' in res.json['errors'][0]
# test_return_private_node_children_list_logged_in_non_contributor
non_contrib = AuthUserFactory()
res = app.get(
private_project_url,
auth=non_contrib.auth,
expect_errors=True)
assert res.status_code == 403
assert 'detail' in res.json['errors'][0]
# test_return_private_node_children_list_logged_in_contributor
res = app.get(private_project_url, auth=user.auth)
assert res.status_code == 200
assert res.content_type == 'application/vnd.api+json'
assert len(res.json['data']) == 1
assert res.json['data'][0]['id'] == component._id
# test_return_private_node_children_osf_group_member_admin
group_mem = AuthUserFactory()
group = OSFGroupFactory(creator=group_mem)
private_project.add_osf_group(group, permissions.ADMIN)
res = app.get(private_project_url, auth=group_mem.auth)
assert res.status_code == 200
# Can view node children that you have implict admin permissions
assert len(res.json['data']) == 1
assert res.json['data'][0]['id'] == component._id
def test_node_children_list_does_not_include_pointers(
self, app, user, component, private_project_url):
res = app.get(private_project_url, auth=user.auth)
assert len(res.json['data']) == 1
def test_node_children_list_does_not_include_unauthorized_projects(
self, app, user, component, private_project, private_project_url):
|
NodeFactory(parent=private_project)
res = app.get(private_project_url, auth=user.auth)
assert len(res.json['data']) == 1
def test_node_children_list_does_not_include_deleted(
self, app, user, public_project, public_component,
component, public_project_url):
child_project = NodeFactory(parent=public_project, creator=user)
child_proj
|
ect.save()
res = app.get(public_project_url, auth=user.auth)
assert res.status_code == 200
ids = [node['id'] for node in res.json['data']]
assert child_project._id in ids
assert 2 == len(ids)
child_project.is_deleted = True
child_project.save()
res = app.get(public_project_url, auth=user.auth)
assert res.status_code == 200
ids = [node['id'] for node in res.json['data']]
assert child_project._id not in ids
assert 1 == len(ids)
def test_node_children_list_does_not_include_node_links(
self, app, user, public_project, public_component,
public_project_url):
pointed_to = ProjectFactory(is_public=True)
public_project.add_pointer(
pointed_to,
auth=Auth(public_project.creator)
)
res = app.get(public_project_url, auth=user.auth)
ids = [node['id'] for node in res.json['data']]
assert public_component._id in ids # sanity check
assert pointed_to._id not in ids
# Regression test for https://openscience.atlassian.net/browse/EMB-593
# Duplicates returned in child count
def test_node_children_related_counts_duplicate_query_results(self, app, user, public_project,
private_project, public_project_url):
user_2 = AuthUserFactory()
# Adding a child component
child = NodeFactory(parent=public_project, creator=user, is_public=True, category='software')
child.add_contributor(user_2, permissions.WRITE, save=True)
# Adding a grandchild
NodeFactory(parent=child, creator=user, is_public=True)
# Adding a node link
public_project.add_pointer(
private_project,
auth=Auth(public_project.creator)
)
# Assert NodeChildrenList returns one result
res = app.get(public_project_url, auth=user.auth)
assert len(res.json['data']) == 1
assert res.json['data'][0]['id'] == child._id
project_url = '/{}nodes/{}/?related_counts=children'.format(API_BASE, public_project._id)
res = app.get(project_url, auth=user.auth)
assert res.status_code == 200
# Verifying related_counts match direct children count (grandchildren not included, pointers not included)
assert res.json['data']['relationships']['children']['links']['related']['meta']['count'] == 1
def test_node_children_related_counts(self, app, user, public_project):
parent = ProjectFactory(creator=user, is_public=False)
user_2 = AuthUserFactory()
parent.add_contributor(user_2, permissions.ADMIN)
child = NodeFactory(parent=parent, creator=user_2, is_public=False, category='software')
NodeFactory(parent=child, creator=user_2, is_public=False)
# child has one component. `user` can view due to implict admin perms
component_url = '/{}nodes/{}/children/'.format(API_BASE, child._id, auth=user.auth)
res = app.get(component_url, auth=user.auth)
assert len(res.json['data']) == 1
project_url = '/{}nodes/{}/?related_counts=children'.format(API_BASE, child._id)
res = app.get(project_url, auth=user.auth)
assert res.sta
|
hj3938/panda3d
|
direct/src/interval/FunctionInterval.py
|
Python
|
bsd-3-clause
| 15,597
| 0.011092
|
"""FunctionInterval module: contains the FunctionInterval class"""
__all__ = ['FunctionInterval', 'EventInterval', 'AcceptInterval', 'IgnoreInterval', 'ParentInterval', 'WrtParentInterval', 'PosInterval', 'HprInterval', 'ScaleInterval', 'PosHprInterval', 'HprScaleInterval', 'PosHprScaleInterval', 'Func', 'Wait']
from panda3d.core import *
from panda3d.direct import *
from direct.showbase.MessengerGlobal import *
from direct.directnotify.DirectNotifyGlobal import directNotify
import Interval
#############################################################
### ###
### See examples of function intervals in IntervalTest.py ###
### ###
#############################################################
class FunctionInterval(Interval.Interval):
# Name counter
functionIntervalNum = 1
# Keep a list of function intervals currently in memory for
# Control-C-Control-V redefining. These are just weakrefs so they
# should not cause any leaks.
if __debug__:
import weakref
FunctionIntervals = weakref.WeakKeyDictionary()
@classmethod
def replaceMethod(self, oldFunction, newFunction):
import types
count = 0
for ival in self.FunctionIntervals:
# print 'testing: ', ival.function, oldFunction
# Note: you can only replace methods currently
if type(ival.function) == types.MethodType:
if (ival.function.im_func == oldFunction):
# print 'found: ', ival.function, oldFunction
ival.function = types.MethodType(newFunction,
ival.function.im_self,
ival.function.im_class)
count += 1
return count
# create FunctionInterval DirectNotify category
notify = directNotify.newCategory('FunctionInterval')
# Class methods
def __init__(self, function, **kw):
"""__init__(function, name = None, openEnded = 1, extraArgs = [])
"""
name = kw.pop('name', None)
openEnded = kw.pop('openEnded', 1)
extraArgs = kw.pop('extraArgs', [])
# Record instance variables
self.function = function
# Create a unique name for the interval if necessary
if name is None:
name = self.makeUniqueName(function)
assert isinstance(name, str)
# Record any arguments
self.extraArgs = extraArgs
self.kw = kw
# Initialize superclass
# Set openEnded true if privInitialize after end time cause interval
# function to be called. If false, privInitialize calls have no effect
# Event, Accept, Ignore intervals default to openEnded = 0
# Parent, Pos, Hpr, etc intervals default to openEnded = 1
Interval.Interval.__init__(self, name, duration = 0.0, openEnded = openEnded)
# For rebinding, let's remember this function interval on the class
if __debug__:
self.FunctionIntervals[self] = 1
@staticmethod
def makeUniqueName(func, suffix = ''):
name = 'Func-%s-%d' % (getattr(func, '__name__', str(func)), FunctionInterval.functionIntervalNum)
FunctionInterval.functionIntervalNum += 1
if suffix:
name = '%s-%s' % (name, str(suffix))
return name
def privInstant(self):
# Evaluate the function
self.function(*self.extraArgs, **self.kw)
# Print debug information
self.notify.debug(
'updateFunc() - %s: executing Function' % self.name)
###
|
FunctionInterval subclass for throwing events ###
class EventInterval(FunctionInterval):
# Initialization
def __init__(self, event, sentArgs=[]):
"""__init__(event, sentArgs)
"""
def sendFunc(event = event, sentArgs = sentArgs):
messenger.send(event, sentArgs)
# Create function interval
FunctionInterval.__init__(self, sendFunc, name = event)
### FunctionInterval subclass for accepting hooks ###
class A
|
cceptInterval(FunctionInterval):
# Initialization
def __init__(self, dirObj, event, function, name = None):
"""__init__(dirObj, event, function, name)
"""
def acceptFunc(dirObj = dirObj, event = event, function = function):
dirObj.accept(event, function)
# Determine name
if (name == None):
name = 'Accept-' + event
# Create function interval
FunctionInterval.__init__(self, acceptFunc, name = name)
### FunctionInterval subclass for ignoring events ###
class IgnoreInterval(FunctionInterval):
# Initialization
def __init__(self, dirObj, event, name = None):
"""__init__(dirObj, event, name)
"""
def ignoreFunc(dirObj = dirObj, event = event):
dirObj.ignore(event)
# Determine name
if (name == None):
name = 'Ignore-' + event
# Create function interval
FunctionInterval.__init__(self, ignoreFunc, name = name)
### Function Interval subclass for adjusting scene graph hierarchy ###
class ParentInterval(FunctionInterval):
# ParentInterval counter
parentIntervalNum = 1
# Initialization
def __init__(self, nodePath, parent, name = None):
"""__init__(nodePath, parent, name)
"""
def reparentFunc(nodePath = nodePath, parent = parent):
nodePath.reparentTo(parent)
# Determine name
if (name == None):
name = 'ParentInterval-%d' % ParentInterval.parentIntervalNum
ParentInterval.parentIntervalNum += 1
# Create function interval
FunctionInterval.__init__(self, reparentFunc, name = name)
### Function Interval subclass for adjusting scene graph hierarchy ###
class WrtParentInterval(FunctionInterval):
# WrtParentInterval counter
wrtParentIntervalNum = 1
# Initialization
def __init__(self, nodePath, parent, name = None):
"""__init__(nodePath, parent, name)
"""
def wrtReparentFunc(nodePath = nodePath, parent = parent):
nodePath.wrtReparentTo(parent)
# Determine name
if (name == None):
name = ('WrtParentInterval-%d' %
WrtParentInterval.wrtParentIntervalNum)
WrtParentInterval.wrtParentIntervalNum += 1
# Create function interval
FunctionInterval.__init__(self, wrtReparentFunc, name = name)
### Function Interval subclasses for instantaneous pose changes ###
class PosInterval(FunctionInterval):
# PosInterval counter
posIntervalNum = 1
# Initialization
def __init__(self, nodePath, pos, duration = 0.0,
name = None, other = None):
"""__init__(nodePath, pos, duration, name)
"""
# Create function
def posFunc(np = nodePath, pos = pos, other = other):
if other:
np.setPos(other, pos)
else:
np.setPos(pos)
# Determine name
if (name == None):
name = 'PosInterval-%d' % PosInterval.posIntervalNum
PosInterval.posIntervalNum += 1
# Create function interval
FunctionInterval.__init__(self, posFunc, name = name)
class HprInterval(FunctionInterval):
# HprInterval counter
hprIntervalNum = 1
# Initialization
def __init__(self, nodePath, hpr, duration = 0.0,
name = None, other = None):
"""__init__(nodePath, hpr, duration, name)
"""
# Create function
def hprFunc(np = nodePath, hpr = hpr, other = other):
if other:
np.setHpr(other, hpr)
else:
np.setHpr(hpr)
# Determine name
if (name == None):
name = 'HprInterval-%d' % HprInterval.hprIntervalNum
HprInterval.hprIntervalNum += 1
# Create function interval
FunctionInterval.__init__(self, hprFunc, name = name)
cl
|
cropleyb/pentai
|
pentai/gui/config.py
|
Python
|
mit
| 737
| 0.004071
|
from kivy.config import Config
from kivy.config import ConfigParser
import pentai.base.logger as log
import os
def config_instance():
return _config
def create_config_instance(ini_file, user_path):
global _config
ini_path = os.path.join(user_path, ini_file)
if not ini_file in os.listdir(user_path):
log.info("Writing initial ini file %s" % ini_path)
imp
|
ort shutil
shutil.copy(ini_file, ini_path)
els
|
e:
log.info("Loading ini file from %s" % ini_path)
_config = ConfigParser()
_config.read(ini_path)
log.info("Updating ini file from %s" % ini_file)
_config.update_config(ini_file)
# Don't need to write it back until something is changed.
return _config
|
tonychee7000/BtcChinaRT
|
btc.py
|
Python
|
gpl-3.0
| 7,964
| 0.002392
|
#!/usr/bin/env python3
#
# Copyright (C) 2013 - Tony Chyi <[email protected]>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
from PyQt5 import QtWidgets, QtCore, QtGui
import json
import urllib.request
import sys
class Timer(QtCore.QThread):
"""Run QTimer in another thread."""
trigger = QtCore.pyqtSignal(int, dict)
def __init__(self, parent=None):
QtCore.QThread.__init__(self, parent)
self.interval = 0
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.tc)
def setup(self, thread_no=1, interval=0):
self.thread_no = thread_no
self.interval = interval
def run(self):
self.timer.start(self.interval)
@QtCore.pyqtSlot()
def tc(self):
try:
val = self.getValue()
self.trigger.emit(self.thread_no, val)
except TypeError as err:
print('\033[31;1mERR:\033[0m', err)
def getValue(self):
"""This is used for get json from specified address."""
url = "https://data.btcchina.com/data/ticker"
try:
p_conn = urllib.request.urlopen(url)
b = p_conn.read()
p_conn.close()
jso = json.loads(b.decode("utf8"))
return jso["ticker"]
except:
return None
class Window(QtWidgets.QWidget):
def __init__(self):
self.TITLE = "BtcChina实时报价"
self.valPrev = 0
QtWidgets.QWidget.__init__(self)
self.setWindowTitle(self.TITLE)
self.move(100, 200)
self.setMinimumSize(500, 500)
self.setMaximumSize(500, 500)
# Get ready for widget
self.label1 = QtWidgets.QLabel("Loading...")
self.label1.setStyleSheet("font-size:50px")
self.label2 = QtWidgets.QLabel("Loading...")
self.label2.setStyleSheet("font-size:12px")
self.label2.setMaximumHeight(60)
self.label2.setMinimumHeight(60)
self.graph = Graphs()
# Set Layout
hbox = QtWidgets.QHBoxLayout()
hbox.addWidget(self.label1)
hbox.addStretch(1)
hbox.addWidget(self.label2)
vbox = QtWidgets.QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(self.graph)
self.setLayout(vbox)
# Start Get Data
timer = Timer(self)
timer.trigger.connect(self.setLabel)
timer.setup(interval=10000)
timer.start()
@QtCore.pyqtSlot(int, dict)
def setLabel(self, thread_no, val):
try:
self.label1.setText("￥{0}".format(val["last"]))
self.label2.setText("High:\t￥{0}\nLow:\t￥{1}\nBuy:\t￥{2}\nSell:\t￥{3}".format(val["high"], val["low"], val["buy"], val["sell"]))
self.graph.setPeak(val["high"], val["low"])
self.graph.addPoint(val["last"])
if float(val["last"]) > self.valPrev:
self.label1.setStyleSheet("font-size:50px;color:red") # WOW! Bull market!
elif float(val["last"]) < self.valPrev:
self.label1.setStyleSheet("font-size:50px;color:green") # Damn bear market!
self.setWindowTitle("￥{0}|{1}".format(val["last"], self.TITLE))
self.valPrev = float(val["last"])
except:
pass
class Graphs(QtWidgets.QWidget):
"""A costomized controller, to show graph on the window."""
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent)
self.flagFirst = True
self.setMinimumSize(300, 300)
self.recentData = [] # To draw lines, a list is needed
self.max_ = 10000
self.min_ = 0
self.valuePrev = self.height()
self.mousePosit = QtCore.QPoint(0, 0)
self.label1 = QtWidgets.QLabel("10k", self)
self.label1.move(0, self.height() * 0.03)
self.label2 = QtWidgets.QLabel("0", self)
self.label2.move(0, self.height() * 0.83)
self.setStep(10)
def paintEvent(self, event):
painter = QtGui.QPainter()
painter.begin(self)
self.drawGird(event, painter)
self.drawFrame(event, painter)
self.drawMouse(event, painter)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
self.draw(event, painter)
painter.end()
def draw(self, event, painter):
"""Draw data line on widget."""
pen = QtGui.QPen(QtGui.QColor(0, 0, 0), 1, QtCore.Qt.SolidLine)
painter.setPen(pen)
xPrev = self.width() * 0.10
xCur = self.width() * 0.10
for value in self.recentData:
xCur += self.step
painter.drawLine(xPrev, self.valuePrev, xCur, value)
self.valuePrev = value
xPrev = xCur
def drawFrame(self, event, painter):
"""Draw the border of chart."""
painter.setPen(QtGui.QColor(0, 0, 0))
painter.drawRect(self.width() * 0.10, self.height() * 0.05, self.width() * 0.90, self.height() * 0.95)
def drawGird(self, event, painter):
"""Draw gird on chart"""
painter.setPen(QtGui.QColor(192, 192, 192))
for v in range(2, 100):
painter.drawLine(self.width() * 0.05 * v, self.height() * 0.05, self.width() * 0.05 * v, self.height())
for h in range(1, 100):
painte
|
r.drawLine(self.width() * 0.10, self.height() * 0.05 * h, self.width(), self.height() * 0.05 * h)
def drawMouse(self, event, painter)
|
:
if self.mousePosit in QtCore.QRect(self.width() * 0.1, self.height() * 0.05, self.width() * 0.9, self.height() * 0.95):
painter.setPen(QtGui.QColor(255, 0, 255))
painter.drawLine(self.mousePosit.x(), self.height() * 0.05, self.mousePosit.x(), self.height())
painter.drawLine(self.width() * 0.10, self.mousePosit.y(), self.width(), self.mousePosit.y())
price = float((1 - (self.mousePosit.y() - self.height() * 0.05) / (self.height() * 0.95)) * (self.max_ - self.min_) + self.min_)
painter.setPen(QtGui.QColor(0, 0, 255))
painter.drawText(QtCore.QPoint(self.width() * 0.1, self.mousePosit.y()), format(price, '.2f'))
def addPoint(self, value):
"""Append a data to data list, for drawing lines."""
value = float(value)
valueCur = int((1.0 - (value - self.min_) / (self.max_ - self.min_)) * self.height() * 0.95 + self.height() * 0.05)
self.recentData.append(valueCur)
if len(self.recentData) >= self.posit:
del self.recentData[0] # Del the first data, look like the chart moving.
self.update()
def setPeak(self, max_, min_):
"""Set the max/min value of the chart."""
self.max_ = float(max_)
self.min_ = float(min_)
self.label1.setText(max_)
self.label1.adjustSize()
self.label2.setText(min_)
self.label2.adjustSize()
self.update()
def setStep(self, step):
"""Set the length of X to a line."""
step = int(step)
self.step = step
self.posit = len(range(int(self.width() * 0.10), int(self.width() * 0.75), step))
def mouseMoveEvent(self, event):
self.mousePosit = event.pos()
self.update()
def main():
app = QtWidgets.QApplication(sys.argv)
win = Window()
win.show()
app.exec_()
if __name__ == "__main__":
main()
|
omarayad1/cantkeepup
|
app/core/helpers.py
|
Python
|
mit
| 1,103
| 0.029918
|
from json import dumps # pragma: no cover
from sqlalchemy.orm import class_mapper # pragma: no cover
from app.models import User, Group # pragma: no cover
def serialize(obj, columns):
# then we return their values in a dict
return dict((c, getattr(obj, c)) for c in columns)
def queryAllToJson(model,conditions):
# we can then use this for your particular example
columns = [c.key for c in class_mapper(model).columns]
seria
|
lized_objs = [
serialize(obj,columns)
for obj in model.query.filter_by(**conditions)
]
return dumps(serialized_objs)
def objectToJson(obj):
columns = [c.key for c in class_mapper(obj.__class__).columns]
serialized_obj = serialize(obj, columns)
return dumps(serialized_obj)
def getUserId(username):
user = User.query.filter_by(username=username).first()
if use
|
r is None:
raise Exception('username %s not found in database' % username)
else:
return user.id
def getGroupId(groupname):
group = Group.query.filter_by(groupname=groupname).first()
if group is None:
raise Exception('groupname %s not found in database' % groupname)
else:
return group.id
|
dcabalas/UNI
|
SN/Python/ocho.py
|
Python
|
gpl-3.0
| 301
| 0.013289
|
class ocho:
def __init__(self):
self.cadena=''
def getString(self):
self.cadena = raw_input("Your desires are orders to me:
|
")
def printString(self):
print "Here's your sentence: {cadena}".format(cadena=self.cadena)
oct = ocho()
oct.getString()
oct
|
.printString()
|
DigitalCampus/django-oppia
|
tests/reports/views/test_completion_rates.py
|
Python
|
gpl-3.0
| 1,385
| 0
|
from django.urls import reverse
from oppia.test import OppiaTestCase
class CompletionRatesViewTest(OppiaTestCase):
fixtures = ['tests/test_user.json',
'tests/test_oppia.json',
'tests/test_quiz.json',
'tests/test_permissions.json',
'tests/test_cohort.json',
'tests/test_course_permissions.json',
'tests/test_usercoursesummary.json']
def setUp(self):
super(CompletionRatesViewTest, self).setUp()
self.allowed_users = [self.admin_user, self.staff_user]
self.disallowed_users = [self.teacher_user, self.normal_user]
def test_view_completion_rates(self):
template = 'reports/completion_rates.html'
url = reverse('reports:completion_rates')
for allowed_user in self.allowed_users:
self.client.force_login(user=allowed_user)
response = self.client.get(url)
self.assertTemplateUsed(response, template)
self.assertEqual(response.status_code, 200)
for disallowed_user in self.disallowed_users:
self.client.force_login(user=disallowed_
|
user)
response = self.client.get(url)
|
self.assertRedirects(response,
'/admin/login/?next=' + url,
302,
200)
|
pierre-chaville/automlk
|
automlk/utils/keras_wrapper.py
|
Python
|
mit
| 2,073
| 0.00193
|
import logging
log = logging.getLogger(__name__)
try:
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import PReLU, LeakyReLU
from keras.optimizers import Adagrad, Adadelta, RMSprop, Adam
from keras.layers.core import Dense
from k
|
eras.utils import to_categorical
import_keras = True
except:
import_keras = False
log.info('could not import keras. Neural networks will not be used')
def keras_create_model(params, problem_type):
# creates a neural net model with params definition
log.info('creating NN structure')
model = Sequentia
|
l()
for l in range(int(params['number_layers'])):
if l == 0:
model.add(Dense(units=params['units'], input_dim=params['input_dim']))
else:
model.add(Dense(units=params['units']))
model.add(Activation(params['activation']))
if params['batch_normalization']:
model.add(BatchNormalization())
model.add(Dropout(params['dropout']))
model.add(Dense(params['output_dim']))
if problem_type == 'classification':
model.add(Activation('sigmoid'))
keras_compile_model(model, params, problem_type)
return model
def keras_compile_model(model, params, problem_type):
# compile the model (usefull to reset weights also)
log.info('compiling NN model')
if params['optimizer'] == 'Adagrad':
optimizer = Adagrad(lr=params['learning_rate'])
elif params['optimizer'] == 'Adadelta':
optimizer = Adadelta(lr=params['learning_rate'])
elif params['optimizer'] == 'Adam':
optimizer = Adam(lr=params['learning_rate'])
else:
optimizer = RMSprop(lr=params['learning_rate'])
if problem_type == 'regression':
loss = 'mse'
elif params['output_dim'] == 2:
loss = 'binary_crossentropy'
else:
loss = 'categorical_crossentropy'
model.compile(loss=loss, optimizer=optimizer)
|
Dklotz-Circle/security_monkey
|
security_monkey/common/route53.py
|
Python
|
apache-2.0
| 3,538
| 0.001696
|
# Copyright 2014 Netflix, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language gover
|
ning permissions and
# limitations under the License.
"""
.. module:: route53
:platform: Unix
:synopsis: Module contains a useful Route53 class.
.. version:: @VERSION@
.. author:: Kevin Glisson ([email protected]), Patrick Kelley ([email protected]) @monkeysecurity
"""
import os
import re
import boto
i
|
mport boto.route53.record
from security_monkey import app
class Route53Service(object):
"""
Class provides useful functions of manipulating Route53 records
"""
def __init__(self, **kwargs):
super(Route53Service, self).__init__(**kwargs)
self.conn = boto.connect_route53()
try:
self.hostname = os.environ['EC2_PUBLIC_HOSTNAME']
except KeyError:
app.logger.warn("We cannot register a domain on non ec2 instances")
def register(self, fqdn, exclusive=False, ttl=60, type='CNAME', regions=None):
fqdn = fqdn.replace('_', '-')
fqdn = re.sub(r'[^\w\-\.]', '', fqdn)
app.logger.debug('route53: register fqdn: {}, hostname: {}'.format(fqdn, self.hostname))
zone_id = self._get_zone_id(fqdn)
if exclusive:
app.logger.debug('route53: making fqdn: {} exclusive'.format(fqdn))
rrsets = self.conn.get_all_rrsets(zone_id, type, name=fqdn)
for rrset in rrsets:
if rrset.name == fqdn + '.':
app.logger.debug('found fqdn to delete: {}'.format(rrset))
for rr in rrset.resource_records:
changes = boto.route53.record.ResourceRecordSets(self.conn, zone_id)
changes.add_change("DELETE", fqdn, type, ttl).add_value(rr)
changes.commit()
changes = boto.route53.record.ResourceRecordSets(self.conn, zone_id)
changes.add_change("CREATE", fqdn, type, ttl).add_value(self.hostname)
changes.commit()
def unregister(self, fqdn, ttl=60, type='CNAME'):
# Unregister this fqdn
fqdn = fqdn.replace('_', '-')
fqdn = re.sub(r'[^\w\-\.]', '', fqdn)
app.logger.debug('route53: unregister fqdn: {}, hostname: {}'.format(fqdn, self.hostname))
zone_id = self._get_zone_id(fqdn)
changes = boto.route53.record.ResourceRecordSets(self.conn, zone_id)
changes.add_change("DELETE", fqdn, type, ttl).add_value(self.hostname)
changes.commit()
def _get_zone_id(self, domain):
if domain[-1] != '.':
domain += '.'
result = self.conn.get_all_hosted_zones()
hosted_zones = result['ListHostedZonesResponse']['HostedZones']
while domain != '.':
for zone in hosted_zones:
app.logger.debug("{} {}".format(zone['Name'], domain))
if zone['Name'] == domain:
return zone['Id'].replace('/hostedzone/', '')
else:
domain = domain[domain.find('.') + 1:]
raise ZoneIDNotFound(domain)
|
chimeno/wagtail
|
wagtail/wagtailsnippets/widgets.py
|
Python
|
bsd-3-clause
| 1,643
| 0.001826
|
from __future__ import absolute_import, unicode_literals
import json
from djan
|
go.template.loader import render_to_string
from django.utils.translation import ugettext_lazy as _
from wagtail.wagtailadmin.widgets import AdminChooser
class
|
AdminSnippetChooser(AdminChooser):
target_content_type = None
def __init__(self, content_type=None, **kwargs):
if 'snippet_type_name' in kwargs:
snippet_type_name = kwargs.pop('snippet_type_name')
self.choose_one_text = _('Choose %s') % snippet_type_name
self.choose_another_text = _('Choose another %s') % snippet_type_name
super(AdminSnippetChooser, self).__init__(**kwargs)
if content_type is not None:
self.target_content_type = content_type
def render_html(self, name, value, attrs):
original_field_html = super(AdminSnippetChooser, self).render_html(name, value, attrs)
model_class = self.target_content_type.model_class()
instance = self.get_instance(model_class, value)
return render_to_string("wagtailsnippets/widgets/snippet_chooser.html", {
'widget': self,
'original_field_html': original_field_html,
'attrs': attrs,
'value': value,
'item': instance,
})
def render_js_init(self, id_, name, value):
content_type = self.target_content_type
return "createSnippetChooser({id}, {content_type});".format(
id=json.dumps(id_),
content_type=json.dumps('{app}/{model}'.format(
app=content_type.app_label,
model=content_type.model)))
|
CANTUS-Project/abbot
|
holy_orders/current.py
|
Python
|
gpl-3.0
| 6,147
| 0.003579
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#--------------------------------------------------------------------------------------------------
# Program Name: holy_orders
# Program Description: Update program for the Abbot Cantus API server.
#
# Filename: holy_orders/current.py
# Purpose: Functions to determine which resources to update.
#
# Copyright (C) 2015, 2016 Christopher Antila
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#--------------------------------------------------------------------------------------------------
'''
Functions to determine which resources to update.
'''
import datetime
import logging
import tornado.log
import iso8601
# settings
LOG_LEVEL = logging.DEBUG
# script-level "globals"
_log = tornado.log.app_log
def _now_wrapper():
'''
A wrapper function for datetime.datetime.utcnow() that can be mocked for automated tests.
'''
return datetime.datetime.now(datetime.timezone.utc)
def get_last_updated(updates_db, rtype):
'''
Get a :class:`datetime` of the most recent update for a resource type.
:param updates_db: A :class:`Connection` to the database that holds
:type updates_db: :class:`sqlite3.Connection`
:param str rtype: The resource type to check.
:returns: The time of the most recent update for the resource type.
:rtype: :class:`datetime.datetime`
If the database's most recent update is recorded as ``'never'``, meaning the resource type was
never updated, the :class:`datetime` returned corresponds to Unix time ``0``.
'''
last_update = updates_db.cursor().execute('SELECT updated FROM rtypes WHERE name=?', (rtype,))
last_update = last_update.fetchone()[0]
if last_update == 'never':
return datetime.datetime.fromtimestamp(0.0)
else:
return iso8601.parse_date(last_update)
def should_update(rtype, config, updates_db):
'''
Check whether HolyOrders "should update" resources of a particular type.
:param str rtype: The resource type to check.
:param config: Dictionary of the configuration file that has our data.
:type config: :class:`configparser.ConfigParser`
:param updates_db: A :class:`Connection` to the database that holds
:type updates_db: :class:`sqlite3.Connection`
:returns: Whether the resource type should be updated.
:rtype: bool
'''
last_update = get_last_updated(updates_db, rtype)
if last_update.year < 1990:
_log.info('should_update({0}) -> True (first update)'.format(rtype))
return True
late_update_delta = _now_wrapper() - last_update
update_freq_delta = config['update_frequency'][rtype]
if update_freq_delta.endswith('d'):
update_freq_delta = datetime.timedelta(days=int(update_freq_delta[:-1]))
else:
update_freq_delta = datetime.timedelta(hours=int(update_freq_delta[:-1]))
if late_update_delta >= update_freq_delta:
_log.info('should_update({0}) -> True'.format(rtype))
return True
else:
_log.info('should_update({0}) -> False'.format(rtype))
return False
def calculate_chant_updates(updates_db):
'''
Determine which dates should be requested for updates of "chant" resources.
:param updates_db: A :class:`Connection` to the database that holds
:type updates_db: :class:`sqlite3.Connection`
:returns: The dates that require an update. These are formatted as YYYYMMD, so they may be used
directly in Drupal URLs.
:rtype: list of str
If no updates are required, the function returns an empty list. To ensure no updates are missed,
this function always includes one additional day than required. For example, if the most recent
update was earlier today, then this function requests updates for both today and yesterday.
However, also note that "days ago" is determined in 24-hour periods, rather than the "yesterday"
style of thinking that humans use. The actual dates requested aren't especially important---it's
enough to know that this function errs on the side of requesting more days than required.
'''
post = []
last_update = get_last_updated(updates_db, 'chant')
delta = _now_wrapper() - last_update
if delta.total_seconds() >= 0:
days_to_request = delta.days + 2
one_day = datetime.timedelta(days=1)
cursor = _now_wrapper()
for _ in range(days_to_request):
post.append(cursor.strftime('%Y%m%d'))
cursor -= one_day
_log.info('Requesting chant updates for {}'.format(post))
return post
def update_db(updates_db, rtype, time):
'''
Revise the updates database to show a new "last updated" time for a resource type.
:param updates_db: A :class:`Connection` to the database that holds
:type updates_db: :class:`sqlite3.Connection`
:param str rtype: The resource type that was updated.
:param time: The time at which the resource type is current.
:type time: :class:`datetime.datetime`
While it's tempting to think that the ``time`` argument should correspond to the moment this
function is called, that's not true---especially for resource types that take considerable time
to update (chants). Therefore the :class:`datetime` given to this functi
|
on should correspond
to the moment just before data are requested from Drupal.
'''
time = time.isoformat()
updates_db.cursor().execute('UPDATE rtypes SET upda
|
ted=? WHERE name=?;', (time, rtype))
updates_db.commit()
|
Lorquas/subscription-manager
|
test/fixture.py
|
Python
|
gpl-2.0
| 18,129
| 0.001655
|
from __future__ import print_function, division, absolute_import
import difflib
import locale
import os
import pprint
import six
import sys
import tempfile
try:
import unittest2 as unittest
except ImportError:
import unittest
# just log py.warnings (and pygtk warnings in particular)
import logging
try:
# 2.7+
logging.captureWarnings(True)
except AttributeError:
pass
from mock import Mock, MagicMock, NonCallableMock, patch, mock_open
from contextlib import contextmanager
from . import stubs
import subscription_manager.injection as inj
import subscription_manager.managercli
from rhsmlib.services import config
# use instead of the normal pid file based ActionLock
from threading import RLock
if six.PY2:
OPEN_FUNCTION = '__builtin__.open'
else:
OPEN_FUNCTION = 'builtins.open'
@contextmanager
def open_mock(content=None, **kwargs):
content_out = six.StringIO()
m = mock_open(read_data=content)
with patch(OPEN_FUNCTION, m, create=True, **kwargs) as mo:
stream = six.StringIO(content)
rv = mo.return_value
rv.write = lambda x: content_out.write(x)
rv.content_out = lambda: content_out.getvalue()
rv.__iter__ = lambda x: iter(stream.readlines())
yield rv
@contextmanager
def open_mock_many(file_content_map=None, **kwargs):
"""
Mock out access to one or many files opened using the builtin "open".
:param file_content_map: A dictionary of path : file_contents
:type file_content_map: dict[str,str]
:param kwargs:
:return:
"""
file_content_map = file_content_map or {}
for key, value in file_content_map.items():
file_content_map[key] = (mock_open(read_data=value), value, six.StringIO())
def get_file(path, *args, **kwargs):
"""
The side effect that will allow us to "open" the right "file".
Not for use outside open_mock_many.
:param path: The path which is passed in to the built
:param args:
:param kwargs:
:return:
"""
try:
rv, file_contents, content_out = file_content_map[path]
except KeyError:
if six.PY2:
raise IOError(2, 'No such file or directory')
else:
raise OSError(2, 'No such file or directory')
rv = rv.return_value
rv.write = lambda x: content_out.write(x)
rv.content_out = lambda: content_out.getvalue()
return rv
with patch(OPEN_FUNCTION, **kwargs) as mo:
mo.side_effect = get_file
yield mo
@contextmanager
def temp_file(content, *args, **kwargs):
try:
kwargs['delete'] = False
kwargs.setdefault('prefix', 'sub-man-test')
fh = tempfile.NamedTemporaryFile(mode='w+', *args, **kwargs)
fh.write(content)
fh.close()
yield fh.name
finally:
os.unlink(fh.name)
@contextmanager
def locale_context(new_locale, category=None):
old_category = category or locale.LC_CTYPE
old_locale = locale.getlocale(old_category)
category = category or
|
locale.LC_ALL
locale.setlocale(category, new_locale)
try:
yield
finally:
locale.setlocale(category, old_locale)
class FakeLogger(object):
def __init__(self):
self.expected_msg = ""
self.msg = None
self.logged_exception
|
= None
def debug(self, buf, *args, **kwargs):
self.msg = buf
def error(self, buf, *args, **kwargs):
self.msg = buf
def exception(self, e, *args, **kwargs):
self.logged_exception = e
def set_expected_msg(self, msg):
self.expected_msg = msg
def info(self, buf, *args, **kwargs):
self.msg = buf
def warning(self, buf, *args, **kwargs):
self.msg = buf
class FakeException(Exception):
def __init__(self, msg=None):
self.msg = msg
def __str__(self):
return repr(self.msg)
class Matcher(object):
@staticmethod
def set_eq(first, second):
"""Useful for dealing with sets that have been cast to or instantiated as lists."""
return set(first) == set(second)
def __init__(self, compare, some_obj):
self.compare = compare
self.some_obj = some_obj
def __eq__(self, other):
return self.compare(self.some_obj, other)
class SubManFixture(unittest.TestCase):
def set_facts(self):
"""Override if you need to set facts for a test."""
return {"mock.facts": "true"}
"""
Can be extended by any subscription manager test case to make
sure nothing on the actual system is read/touched, and appropriate
mocks/stubs are in place.
"""
def setUp(self):
# No matter what, stop all patching (even if we have a failure in setUp itself)
self.addCleanup(patch.stopall)
# Never attempt to use the actual managercli.cfg which points to a
# real file in etc.
self.mock_cfg_parser = stubs.StubConfig()
original_conf = subscription_manager.managercli.conf
def unstub_conf():
subscription_manager.managercli.conf = original_conf
# Mock makes it damn near impossible to mock a module attribute (which we shouldn't be using
# in the first place because it's terrible) so we monkey-patch it ourselves.
# TODO Fix this idiocy by not reading the damn config on module import
subscription_manager.managercli.conf = config.Config(self.mock_cfg_parser)
self.addCleanup(unstub_conf)
facts_host_patcher = patch('rhsmlib.dbus.facts.FactsClient', auto_spec=True)
self.mock_facts_host = facts_host_patcher.start()
self.mock_facts_host.return_value.GetFacts.return_value = self.set_facts()
# By default mock that we are registered. Individual test cases
# can override if they are testing disconnected scenario.
id_mock = NonCallableMock(name='FixtureIdentityMock')
id_mock.exists_and_valid = Mock(return_value=True)
id_mock.uuid = 'fixture_identity_mock_uuid'
id_mock.name = 'fixture_identity_mock_name'
id_mock.cert_dir_path = "/not/a/real/path/to/pki/consumer/"
id_mock.keypath.return_value = "/not/a/real/key/path"
id_mock.certpath.return_value = "/not/a/real/cert/path"
# Don't really care about date ranges here:
self.mock_calc = NonCallableMock()
self.mock_calc.calculate.return_value = None
# Avoid trying to read real /etc/yum.repos.d/redhat.repo
self.mock_repofile_path_exists_patcher = patch('subscription_manager.repolib.YumRepoFile.path_exists')
mock_repofile_path_exists = self.mock_repofile_path_exists_patcher.start()
mock_repofile_path_exists.return_value = True
inj.provide(inj.IDENTITY, id_mock)
inj.provide(inj.PRODUCT_DATE_RANGE_CALCULATOR, self.mock_calc)
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, stubs.StubEntitlementStatusCache())
inj.provide(inj.POOL_STATUS_CACHE, stubs.StubPoolStatusCache())
inj.provide(inj.PROD_STATUS_CACHE, stubs.StubProductStatusCache())
inj.provide(inj.CONTENT_ACCESS_MODE_CACHE, stubs.StubContentAccessModeCache())
inj.provide(inj.SUPPORTED_RESOURCES_CACHE, stubs.StubSupportedResourcesCache())
inj.provide(inj.SYSPURPOSE_VALID_FIELDS_CACHE, stubs.StubSyspurposeValidFieldsCache())
inj.provide(inj.CURRENT_OWNER_CACHE, stubs.StubCurrentOwnerCache)
inj.provide(inj.OVERRIDE_STATUS_CACHE, stubs.StubOverrideStatusCache())
inj.provide(inj.RELEASE_STATUS_CACHE, stubs.StubReleaseStatusCache())
inj.provide(inj.AVAILABLE_ENTITLEMENT_CACHE, stubs.StubAvailableEntitlementsCache())
inj.provide(inj.PROFILE_MANAGER, stubs.StubProfileManager())
# By default set up an empty stub entitlement and product dir.
# Tests need to modify or create their own but nothing should hit
# the system.
self.ent_dir = stubs.StubEntitlementDirectory()
inj.provide(inj.ENT_DIR, self.ent_dir)
self.prod_dir = stubs.StubProductDirectory()
inj.provide(inj.PROD_DIR, self.prod_dir)
# Installed products m
|
reinforceio/tensorforce
|
tensorforce/core/parameters/random.py
|
Python
|
apache-2.0
| 4,125
| 0.002182
|
# Copyright 2020 Tensorforce Team. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
import tensorflow as tf
from tensorforce.core.parameters import Parameter
class Random(Parameter):
"""
Random hyperparameter (specification key: `random`).
Args:
distribution ("normal" | "uniform"): Distribution type for random hyperparameter value
(<span style="color:#C00000"><b>required</b></span>).
kwargs: Additional arguments dependent on distribution type.<br>
Normal distribution:
<ul>
<li><b>mean</b> (<i>float</i>) – Mean
(<span style="color:#00C000"><b>default</b></span>: 0.0).</li>
<li><b>s
|
tddev</b> (<i>float > 0.0</i>) – Standard deviation
(<span style="color:#00C000"><b>default</b></span>: 1.0).</li>
</ul>
Uniform distribution:
<ul>
<li><b>minval</b> (<i>int / float</i>) – Lower bound
(<span style="color:#00C000"><b>default</b></span>: 0 / 0.0).</li>
|
<li><b>maxval</b> (<i>float > minval</i>) – Upper bound
(<span style="color:#00C000"><b>default</b></span>: 1.0 for float,
<span style="color:#C00000"><b>required</b></span> for int).</li>
</ul>
name (string): <span style="color:#0000C0"><b>internal use</b></span>.
dtype (type): <span style="color:#0000C0"><b>internal use</b></span>.
shape (iter[int > 0]): <span style="color:#0000C0"><b>internal use</b></span>.
min_value (dtype-compatible value): <span style="color:#0000C0"><b>internal use</b></span>.
max_value (dtype-compatible value): <span style="color:#0000C0"><b>internal use</b></span>.
"""
def __init__(
self, *, distribution, name=None, dtype=None, shape=(), min_value=None, max_value=None,
**kwargs
):
assert dtype in ('int', 'float')
assert distribution in ('normal', 'uniform')
self.distribution = distribution
self.kwargs = kwargs
super().__init__(
name=name, dtype=dtype, shape=shape, min_value=min_value, max_value=max_value
)
def min_value(self):
if self.distribution == 'uniform':
return self.spec.py_type()(self.kwargs.get('minval', 0))
else:
return super().min_value()
def max_value(self):
if self.distribution == 'uniform':
return self.spec.py_type()(self.kwargs.get('maxval', 1.0))
else:
return super().max_value()
def final_value(self):
if self.distribution == 'normal':
return self.spec.py_type()(self.kwargs.get('mean', 0.0))
elif self.distribution == 'uniform':
return self.spec.py_type()(
(self.kwargs.get('maxval', 1.0) + self.kwargs.get('minval', 0.0)) / 2.0
)
else:
return super().final_value()
def parameter_value(self, *, step):
if self.distribution == 'normal':
parameter = tf.random.normal(
shape=self.spec.shape, dtype=self.spec.tf_type(), mean=self.kwargs.get('mean', 0.0),
stddev=self.kwargs.get('stddev', 1.0)
)
elif self.distribution == 'uniform':
parameter = tf.random.uniform(
shape=self.spec.shape, dtype=self.spec.tf_type(),
minval=self.kwargs.get('minval', 0), maxval=self.kwargs.get('maxval')
)
return parameter
|
cagdass/ml-easy-peer-grade
|
setup.py
|
Python
|
gpl-3.0
| 525
| 0.04381
|
from distutils.core import setup
setup(
name = 'ml_easy_
|
peer_grade',
packages = ['ml_easy_peer_grade'],
version = '0.18',
scripts=['bin/ml_easy_peer_grade'],
description = 'Ez peer grade your project members, exclusive to privileged Bilkent students',
author = 'Cuklahan Dorum',
author_email = '[email protected]',
url = 'https://github.com/cagdass/ml-easy-peer-grade',
download_url =
|
'https://github.com/cagdass/ml-easy-peer-grade/tarball/0.1',
keywords = ['testing'],
classifiers = [],
)
|
makoshark/Mediawiki-Utilities
|
mw/api/collections/revisions.py
|
Python
|
mit
| 8,519
| 0.006926
|
import logging
from ...util import none_or
from ..errors import MalformedResponse
from .collection import Collection
logger = logging.getLogger("mw.api.collections.revisions")
class Revisions(Collection):
"""
A collection of revisions indexes by title, page_id and user_text.
Note that revisions of deleted pages are queriable via
:class:`mw.api.DeletedRevs`.
"""
PROPERTIES = {'ids', 'flags', 'timestamp', 'user', 'userid', 'size',
'sha1', 'contentmodel', 'comment', 'parsedcomment',
'content', 'tags', 'flagged'}
DIFF_TO = {'prev', 'next', 'cur'}
# This is *not* the right way to do this, but it should work for all queries.
MAX_REVISIONS = 50
def get(self, rev_id, **kwargs):
"""
Get a single revision based on it's ID. Throws a :py:class:`KeyError`
if the rev_id cannot be found.
:Parameters:
rev_id : int
Revision ID
``**kwargs``
Passed to :py:meth:`query`
:Returns:
A single rev dict
"""
rev_id = int(rev_id)
revs = list(self.query(revids={rev_id}, **kwargs))
if len(revs) < 1:
raise KeyError(rev_id)
else:
return revs[0]
def query(self, *args, limit=None, **kwargs):
"""
Get revision information.
See `<https://www.mediawiki.org/wiki/API:Properties#revisions_.2F_rv>`_
:Parameters:
properties : set(str)
Which properties to get for each revision:
* ids - The ID of the revision
* flags - Revision flags (minor)
* timestamp - The timestamp of the revision
* user - User that made the revision
* userid - User id of revision creator
* size - Length (bytes) of the revision
* sha1 - SHA-1 (base 16) of the revision
* contentmodel - Content model id
* comment - Comment by the user for revision
* parsedcomment - Parsed comment by the user for the revision
* content - Text of the revision
* tags - Tags for the revision
limit : int
Limit how many revisions will be returned
No more than 500 (5000 for bots) allowed
start_id : int
From which revision id to start enumeration (enum)
end_id : int
Stop revision enumeration on this revid
start : :class:`mw.Timestamp`
From which revision timestamp to start enumeration (enum)
end : :class:`mw.Timestamp`
Enumerate up to this timestamp
direction : str
"newer" or "older"
user : str
Only include revisions made by user_text
excludeuser : bool
Exclude revisions made by user
tag : str
Only list revisions tagged with this tag
expandtemplates : bool
Expand templates in revision content (requires "content" propery)
generatexml : bool
Generate XML parse tree for revision content (requires "content" propery)
parse : bool
Parse revision content (requires "content" propery)
section : int
Only retrieve the content of this section number
token : set(str)
Which tokens to obtain for each revision
* rollback - See `<https://www.mediawiki.org/wiki/API:Edit_-_Rollback#Token>`_
rvcontinue : str
When more results are available, use this to continue
diffto : int
Revision ID to diff each revision to. Use "prev", "next" and
"cur" for the previous, next and current revision respectively
difftotext : str
Text to diff each revision to. Only diffs a limited number of
revisions. Overrides diffto. If section is set, only that
section will be diffed against this text
contentformat : str
Serialization format used for difftotext and expected for output of content
* text/x-wiki
* text/javascript
* text/css
* text/plain
* application/json
:Returns:
An iterator of rev dicts returned from the API.
"""
revisions_yielded = 0
done = False
while not done:
if limit == None:
kwargs['limit'] = self.MAX_REVISIONS
else:
kwargs['limit'] = min(limit - revisions_yielded, self.MAX_REVISIONS)
rev_docs, rvcontinue = self._query(*args, **kwargs)
for doc in rev_docs:
yield doc
revisions_yielded += 1
if limit != None and revisions_yielded >= limit:
done = True
break
if rvcontinue != None and len(rev_docs) > 0:
kwargs['rvcontinue'] = rvcontinue
else:
done = True
def _query(self, revids=None, titles=None, pageids=None, properties=None,
limit=None, start_id=None, end_id=None, start=None,
end=None, direction=None, user=None, excludeuser=None,
tag=None, expandtemplates=None, generatexml=None,
parse=None, section=None, token=None, rvcontinue=None,
diffto=None, difftotext=None, contentformat=None):
params = {
'action': "query",
'prop': "revisions"
}
params['re
|
vids'] =
|
self._items(revids, type=int)
params['titles'] = self._items(titles)
params['pageids'] = self._items(pageids, type=int)
params['rvprop'] = self._items(properties, levels=self.PROPERTIES)
if revids == None: # Can't have a limit unless revids is none
params['rvlimit'] = none_or(limit, int)
params['rvstartid'] = none_or(start_id, int)
params['rvendid'] = none_or(end_id, int)
params['rvstart'] = self._check_timestamp(start)
params['rvend'] = self._check_timestamp(end)
params['rvdir'] = self._check_direction(direction)
params['rvuser'] = none_or(user, str)
params['rvexcludeuser'] = none_or(excludeuser, int)
params['rvtag'] = none_or(tag, str)
params['rvexpandtemplates'] = none_or(expandtemplates, bool)
params['rvgeneratexml'] = none_or(generatexml, bool)
params['rvparse'] = none_or(parse, bool)
params['rvsection'] = none_or(section, int)
params['rvtoken'] = none_or(token, str)
params['rvcontinue'] = none_or(rvcontinue, int)
params['rvdiffto'] = self._check_diffto(diffto)
params['rvdifftotext'] = none_or(difftotext, str)
params['rvcontentformat'] = none_or(contentformat, str)
doc = self.session.get(params)
try:
if 'query-continue' in doc:
rvcontinue = doc['query-continue']['revisions']['rvcontinue']
else:
rvcontinue = None
pages = doc['query'].get('pages', {}).values()
rev_docs = []
for page_doc in pages:
if 'missing' in page_doc or 'revisions' not in page_doc: continue
page_rev_docs = page_doc['revisions']
del page_doc['revisions']
for rev_doc in page_rev_docs:
rev_doc['page'] = page_doc
rev_docs.ext
|
HopeFOAM/HopeFOAM
|
ThirdParty-0.1/ParaView-5.0.1/VTK/Imaging/Core/Testing/Python/TestAllMaskBits.py
|
Python
|
gpl-3.0
| 3,568
| 0.002522
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
=========================================================================
Program: Visualization Toolkit
Module: TestNamedColorsIntegration.py
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
======
|
===================================================================
'''
import vtk
import vtk.test.Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
class TestAllMaskBits(vtk.test.Testing.vtkTest):
def testAllMaskBits(self):
# This script calculates the luminance of an image
renWin = vtk.vtkRenderWindow()
|
# Image pipeline
image1 = vtk.vtkTIFFReader()
image1.SetFileName(VTK_DATA_ROOT + "/Data/beach.tif")
# "beach.tif" image contains ORIENTATION tag which is
# ORIENTATION_TOPLEFT (row 0 top, col 0 lhs) type. The TIFF
# reader parses this tag and sets the internal TIFF image
# orientation accordingly. To overwrite this orientation with a vtk
# convention of ORIENTATION_BOTLEFT (row 0 bottom, col 0 lhs ), invoke
# SetOrientationType method with parameter value of 4.
image1.SetOrientationType(4)
shrink = vtk.vtkImageShrink3D()
shrink.SetInputConnection(image1.GetOutputPort())
shrink.SetShrinkFactors(2, 2, 1)
operators = ["ByPass", "And", "Nand", "Xor", "Or", "Nor"]
operator = dict()
mapper = dict()
actor = dict()
imager = dict()
for idx, op in enumerate(operators):
if op != "ByPass":
operator.update({idx: vtk.vtkImageMaskBits()})
operator[idx].SetInputConnection(shrink.GetOutputPort())
eval('operator[' + str(idx) + '].SetOperationTo' + op + '()')
operator[idx].SetMasks(255, 255, 0)
mapper.update({idx: vtk.vtkImageMapper()})
if op != "ByPass":
mapper[idx].SetInputConnection(operator[idx].GetOutputPort())
else:
mapper[idx].SetInputConnection(shrink.GetOutputPort())
mapper[idx].SetColorWindow(255)
mapper[idx].SetColorLevel(127.5)
actor.update({idx: vtk.vtkActor2D()})
actor[idx].SetMapper(mapper[idx])
imager.update({idx: vtk.vtkRenderer()})
imager[idx].AddActor2D(actor[idx])
renWin.AddRenderer(imager[idx])
column = 0
row = 0
deltaX = 1.0 / 3.0
deltaY = 1.0 / 2.0
for idx in range(len(operators)):
imager[idx].SetViewport(column * deltaX, row * deltaY, (column + 1) * deltaX, (row + 1) * deltaY)
column += 1
if column > 2:
column = 0
row += 1
renWin.SetSize(384, 256)
# render and interact with data
iRen = vtk.vtkRenderWindowInteractor()
iRen.SetRenderWindow(renWin);
renWin.Render()
img_file = "TestAllMaskBits.png"
vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
vtk.test.Testing.interact()
if __name__ == "__main__":
vtk.test.Testing.main([(TestAllMaskBits, 'test')])
|
mtils/sqliter
|
examples/testdata.py
|
Python
|
mit
| 9,753
| 0.022147
|
from __future__ import print_function
dictData = [
{'forename':'Marc','surname':'Mine','age':35, 'tags':('family','work'),
'job':{'name':'Baker','category':'Business'},
'hobbies':[{'name':'swimming','period':7},
{'name':'reading','period':1}]},
{'forename':'Mike','surname':'Meyer','age':14, 'tags':('work',),
'job':{'name':'Banker','category':'Business'},
'hobbies':[{'name':'swimming','period':14}]},
{'forename':'Marc','surname':'Andrew','age':78, 'tags':('hobby','work'),
'job':{'name':'Police','category':'Government'},
'hobbies':[{'name':'swimming','period':7},
{'name':'music','period':1},
{'name':'reading','period':2}]},
{'forename':'Marc','surname':'Muscels','age':35, 'tags':('family','hobby'),
'job':{'name':'Teacher','category':'Social'},
'hobbies':[{'name':'math','period':30},
{'name':'ski','period':365}]},
{'forename':'Andy','surname':'Young','age':11, 'tags':('family','work'),
'job':{'name':'President','category':'Government'},
'hobbies':[{'name':'swimming','period':2},
{'name':'fitness','period':3},
{'name':'reading','period':4},
{'name':'rc-cars','period':14}]},
{'forename':'Andy','surname':'Andy','age':51, 'tags':('family',),
'job':{'name':'Killer','category':'Business'},
'hobbies':[{'name':'counterstrike','period':1}]}
]
class AutoSet(object):
def __init__(self, **kwargs):
for name in kwargs:
self.__setattr__(name, kwargs[name])
class Person(AutoSet):
forename = ''
surname = ''
tags = ()
age = 0
job = None
hobbies = []
def __str__(self):
return '<Person surname={0} forename={1} age={2} tags={3}>'.format(self.forename, self.surname,
self.age, self.tags)
class Job(AutoSet):
name = ''
category = ''
class Hobby(AutoSet):
name = ''
period = 0
objectData = [
Person(forename='Marc',surname='Mine',age=35, tags=('family','work'),
job=Job(name='Baker',category='Business'),
hobbies=[Hobby(name='swimming',period=7),
Hobby(name='reading',period=1)]
),
Person(forename='Mike',surname='Meyer',age=14, tags=('work'),
job=Job(name='Banker',category='Business'),
hobbies=[Hobby(name='swimming',period=14)]
),
Person(forename='Marc',surname='Andrew',age=78, tags=('hobby','work'),
job=Job(name='Police',category='Government'),
hobbies=[Hobby(name='swimming',period=7),
Hobby(name='music',period=1),
Hobby(name='reading',period=2),]
),
Person(forename='Marc',surname='Muscels',age=35, tags=('family','hobby'),
job=Job(name='Teacher',category='Social'),
hobbies=[Hobby(name='math',period=30),
Hobby(name='ski',period=365)]
),
Person(forename='Andy',surname='Young',age=11, tags=('family','work'),
job=Job(name='President',category='Government'),
hobbies=[Hobby(name='swimming',period=2),
Hobby(name='fitness',period=3),
Hobby(name='reading',period=4),
Hobby(name='rc-cars',period=14)]
),
Person(forename='Andy',surname='Andy',age=51, tags=('family',),
job=Job(name='Killer',category='Business'),
hobbies=[Hobby(name='counterstrike',period=1)]
)
]
if __name__ == '__main__':
from sqliter.query import select, and_, or_, c, test
dictData = objectData
matchTest = {'name':'Olaf','weight':67.3,'age':33,'married':True}
def dev_null(self, *args):
pass
printOut = True
if printOut:
print_func = print
else:
print_func = dev_null
print_func('-------- SELECT FROM dictData')
for name in select().from_(dictData):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE forename = Marc')
for name in select().from_(dictData).where(forename='Marc'):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE surname IN ("Meyer","Muscels")')
for name in select().from_(dictData).where(c('surname').in_('Meyer','Muscels')):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE age > 32')
for name in select().from_(dictData).where(c('age') > 32):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE forname=surname')
for name in select().from_(dictData).where(c('forename') == c('surname')):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE forname=surname OR age < 20')
for name in select().from_(dictData).where(or_(c('forename') == c('surname'),c('age') < 20)):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE forname="Marc" AND surname == "Andrew"')
for name in select().from_(dictData).where(and_(c('forename') == 'Marc',c('surname') == 'Andrew')):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE "family" IN tags')
for
|
name in select().from_(dictData).where(c('"family"').in_(c('tags'))):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE job.name == "President"')
for name in select().from_(dictData).where(c('job.name') == 'President'):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE job.category
|
== "Business"')
for name in select().from_(dictData).where(c('job.category') == 'Business'):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE job.category IN ("Business", "Social")')
for name in select().from_(dictData).where(c('job.category').in_('Business','Social')):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE hobbies[*].name == "reading"')
for name in select().from_(dictData).where(c('hobbies[*].name') == "reading"):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE hobbies[*].period < 7')
for name in select().from_(dictData).where(c('hobbies[*].period') < 7):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE asdkuh < 7')
for name in select().from_(dictData).where(c('asdkuh') < 7):
print_func(name)
print_func('-------- SELECT FROM dictData WHERE hobbies[*].period < 7.first()')
print_func(select().from_(dictData).where(c('hobbies[*].period') < 7).first())
print_func('-------- SELECT FROM dictData WHERE hobbies[*].period < 7.last()')
print_func(select().from_(dictData).where(c('hobbies[*].period') < 7).last())
print_func('-------- TEST IF age > 22')
print_func(test(c('age') > 22).match(matchTest))
print_func('-------- TEST IF age < 22')
print_func(test(c('age') < 22).match(matchTest))
print_func('-------- TEST IF name == "Olaf"')
print_func(test(c('name') == 'Olaf').match(matchTest))
print_func('-------- TEST IF name != "Olaf"')
print_func(test(c('name') != 'Olaf').match(matchTest))
print_func('-------- TEST IF name == "Olafs"')
print_func(test(c('name') == 'Olafs').match(matchTest))
print_func('-------- TEST IF name LIKE "Ol%"')
print_func(test(c('name').like('Ol%')).match(matchTest))
print_func('-------- TEST IF name LIKE "%laf"')
print_func(test(c('name').like('%laf')).match(matchTest))
print_func('-------- TEST IF name LIKE "O%f"')
print_func(test(c('name').like('O%f')).match(matchTest))
print_func('-------- TEST IF name LIKE "olaf"')
print_func(test(c('name
|
concurrence/concurrence
|
lib/concurrence/database/mysql/proxy.py
|
Python
|
bsd-3-clause
| 3,790
| 0.007916
|
# Copyright (C) 2009, Hyves (Startphone Ltd.)
#
# This module is part of the Concurrence Framework and is released under
# the New BSD License: http://www.opensource.org/licenses/bsd-license.php
from concurrence.timer import Timeout
from concurrence.database.mysql import ProxyProtocol, PacketReader, PACKET_READ_RESULT, CLIENT_STATES, SERVER_STATES
class Proxy(object):
#errors
EOF_READ = -1
EOF_WRITE = -2
#direction
CLIENT_TO_SERVER = 1
SERVER_TO_CLIENT = 2
def __init__(self, clientStream, serverStream, buffer, initState):
self.clientStream = clientStream
self.serverStream = serverStream
self.readStream = self.clientStream
self.writeStream = self.serverStream
self.direction = self.CLIENT_TO_SERVER
self.protocol = ProxyProtocol(initState)
self.reader = PacketReader()
self.buffer = buffer
self.remaining = 0
def close(self):
self.clientStream = None
self.serverStream = None
self.readStream = None
self.writeStream = None
self.protocol = None
self.reader = None
self.buffer = None
def reset(self, state):
self.protocol.reset(state)
def readFromStream(self):
#read some data from stream into buffer
if self.remaining:
#some leftover partially read packet from previous read, put it in front of buffer
self.buffer.limit = self.buffer.position + self.remaining
self.buffer.compact()
else:
#normal clear, position = 0, limit = capacity
self.buffer.clear()
#read data from socket
return self.readStream.read(self.buffer, Timeout.current())
def writeToStream(self):
#forward data to receiving socket
self.buffer.flip()
while self.buffer.remaining:
if not self.writeStream.write(self.buffer, Timeout.current()):
return False
return True
def next(self, readResult, newState, prevState):
return 0
def cycle(self, readProtocol):
if not self.readFromStream():
return self.EOF_READ
#inspect data read according to protocol
n = 0
self.buffer.flip()
while True:
readResult, newState, prevState = readProtocol(self.reader, self.buffer)
#make note of any remaining data (half read packets),
# we use buffer.compact to put remainder in front next time around
self.remaining = self.buffer.remaining
#take action depending on state transition
n = self.next(readResult, newState, prevState)
if n != 0:
break
if not (readResult & PACKET_READ_RESULT.MORE):
break
if n == 0:
#write data trough to write stream
if not self.writeToStream():
return self.EOF_WRITE
|
return n
def run(self):
while True:
state = self.protocol.state
if state in SERVER_STATES:
self.direction = self.SE
|
RVER_TO_CLIENT
self.readStream = self.serverStream
self.writeStream = self.clientStream
n = self.cycle(self.protocol.readServer)
elif state in CLIENT_STATES:
self.direction = self.CLIENT_TO_SERVER
self.readStream = self.clientStream
self.writeStream = self.serverStream
n = self.cycle(self.protocol.readClient)
else:
assert False, "Unknown state %s" % state
if n < 0:
return n
|
jhartz/masterchess
|
setup.py
|
Python
|
gpl-3.0
| 5,318
| 0.003197
|
"""
Setup/build script for MasterChess
For usage info, see readme.md
"""
import os, sys, subprocess
from distutils.dir_util import copy_tree
from setuptools import setup
from MasterChessGUI import __description__, __copyright__, __version__
def get_folder(path):
if isinstance(path, list):
return [get_folder(i) for i in path]
else:
return (path, [os.path.join(path, i) for i in os.listdir(path) if i[:1] != "." and os.path.isfile(os.path.join(path, i))])
DATA_FILES = [get_folder("resources")]
DATA_FILES_MAC = ["QuickLook.py"]
DATA_MODULE_PACKAGES = ["MasterChess"]
PY2EXE_BUNDLE = False
options = {
"name": "MasterChess",
"version": __version__,
"description": __description__,
"author": "Jake Hartz",
"author_email": "[email protected]",
"license": "GPL",
"url": "http://jhartz.github.io/masterchess/"
}
if sys.platform == "darwin" and "py2app" in sys.argv:
options.update({
"setup_requires": ["py2app"],
"app": ["MasterChessGUI.py"],
"data_files": DATA_FILES + DATA_FILES_MAC,
"options": {
"py2app": {
"argv_emulation": True,
"iconfile": "resources/Chess.icns",
"plist": {
"CFBundleIdentifier": "com.github.jhartz.masterchess",
"CFBundleGetInfoString": __description__,
"NSHumanReadableCopyright": __copyright__,
"UTExportedTypeDeclarations": [
{
"UTTypeIdentifier": "com.github.jhartz.masterchess.mcdb",
"UTTypeDescription": "MasterChess database",
#"UTTypeIconFile": "Chess.icns",
"UTTypeConformsTo": [
"public.data"
],
"UTTypeTagSpecification": {
"public.filename-extension": "mcdb"
}
}
],
"CFBundleDocumentTypes": [
{
#"CFBundleTypeExtensions": [
# "mcdb"
#],
"CFBundleTypeIconFile": "Chess.icns",
#"CFBundleTypeName": "MasterChess database",
"CFBundleTypeName": "MasterChess database",
"LSItemContentTypes": [
"com.github.jhartz.masterchess.mcdb"
],
"CFBundleTypeRole": "Editor",
"LSHandlerRank": "Owner"
}
|
]
}
}
}
})
elif sys.platform == "win32" and "py2exe" in sys.argv:
import py2exe
options.update({
"setup_requires": ["py2exe"],
"data_files": DATA_FILES,
"windows": [
{
"script": "MasterChessGUI.py",
"icon_resources": [(1, "resources/Chess.ico")],
"other_resources": [(u"VERSIONTAG", 1, "MasterChess " + __version__)] # TODO: Te
|
st this!!
}
]
})
if PY2EXE_BUNDLE:
options.update({
"options": {
"py2exe": {
"bundle_files": 1
}
},
"zipfile": None
})
else:
options.update({
"scripts": ["MasterChessGUI.py"],
"packages": DATA_MODULE_PACKAGES,
"data_files": DATA_FILES,
"install_requires": ["wx"]
})
setup(**options)
if sys.platform == "darwin" and "py2app" in sys.argv:
# If we have a compiled MC-QuickLook or MC-Spotlight, include that
if os.path.isdir(os.path.join("dist", "MasterChess.app", "Contents")):
# QuickLook
loc = os.path.join("Mac components", "MC-QuickLook", "Build", "Release", "MC-QuickLook.qlgenerator")
if not os.path.exists(loc):
# Try debug version
loc = os.path.join("Mac components", "MC-QuickLook", "Build", "Debug", "MC-QuickLook.qlgenerator")
if os.path.exists(loc):
print ""
print "Copying MC-QuickLook to app bundle"
copy_tree(loc, os.path.join("dist", "MasterChess.app", "Contents", "Library", "QuickLook", os.path.basename(loc)))
print "Reloading quicklookd"
try:
subprocess.call(["qlmanage", "-r"])
subprocess.call(["qlmanage", "-r", "cache"])
except OSError:
print "Error calling qlmanage (manually call `qlmanage -r` and `qlmanage -r cache` to reload quicklookd)"
# Spotlight
loc = os.path.join("Mac components", "MC-Spotlight", "Build", "Release", "MC-Spotlight.mdimporter")
if not os.path.exists(loc):
# Try debug version
loc = os.path.join("Mac components", "MC-Spotlight", "Build", "Debug", "MC-Spotlight.mdimporter")
if os.path.exists(loc):
print ""
print "Copying MC-Spotlight to app bundle"
copy_tree(loc, os.path.join("dist", "MasterChess.app", "Contents", "Library", "Spotlight", os.path.basename(loc)))
|
kittiu/sale-workflow
|
sale_exception/models/sale.py
|
Python
|
agpl-3.0
| 2,008
| 0
|
# -*- coding: utf-8 -*-
# © 2011 Raphaël Valyi,
|
Renato Lima, Guewen Baconnier, Sodexis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models, fields
class ExceptionRule(models.Model):
_inherit = 'exception.rule'
rule_group = fields.Selection(
selection_add=[('sale', 'Sale')],
)
model = fields.Selection(
selection_add=[
('sale.order', 'Sale order'),
('sale.order.line', '
|
Sale order line'),
])
class SaleOrder(models.Model):
_inherit = ['sale.order', 'base.exception']
_name = 'sale.order'
_order = 'main_exception_id asc, date_order desc, name desc'
rule_group = fields.Selection(
selection_add=[('sale', 'Sale')],
default='sale',
)
@api.model
def test_all_draft_orders(self):
order_set = self.search([('state', '=', 'draft')])
order_set.test_exceptions()
return True
@api.constrains('ignore_exception', 'order_line', 'state')
def sale_check_exception(self):
orders = self.filtered(lambda s: s.state == 'sale')
if orders:
orders._check_exception()
@api.onchange('order_line')
def onchange_ignore_exception(self):
if self.state == 'sale':
self.ignore_exception = False
@api.multi
def action_confirm(self):
if self.detect_exceptions():
return self._popup_exceptions()
else:
return super(SaleOrder, self).action_confirm()
@api.multi
def action_draft(self):
res = super(SaleOrder, self).action_draft()
orders = self.filtered(lambda s: s.ignore_exception)
orders.write({
'ignore_exception': False,
})
return res
def _sale_get_lines(self):
self.ensure_one()
return self.order_line
@api.model
def _get_popup_action(self):
action = self.env.ref('sale_exception.action_sale_exception_confirm')
return action
|
elbeardmorez/quodlibet
|
quodlibet/quodlibet/qltk/unity.py
|
Python
|
gpl-2.0
| 2,257
| 0
|
# -*- coding: utf-8 -*-
# Copyright 2013 Christoph Reiter
#
# 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.
"""Everything related to Ubuntu Unity integration (quicklist..)
See the MPRIS plugin for sound menu integration.
"""
import gi
from quodlibet import _
from quodlibet.util import gi_require_versions
is_unity = True
try:
gi.require_version("Dbusmenu", "0.4")
from gi.repository import Dbusmenu
except (ValueError, ImportError):
is_unity = False
try:
gi_require_versions(
|
"Unity", ["7.0", "6.0", "5.0"])
from gi.repository import Unity
except (ValueError, ImportError):
is_unity = False
|
def init(desktop_id, player):
"""Set up unity integration.
* desktop_id: e.g. 'quodlibet.desktop'
* player: BasePlayer()
http://developer.ubuntu.com/api/devel/ubuntu-12.04/c/Unity-5.0.html
http://developer.ubuntu.com/api/devel/ubuntu-13.10/c/Unity-7.0.html
"""
if not is_unity:
return
launcher = Unity.LauncherEntry.get_for_desktop_id(desktop_id)
main = Dbusmenu.Menuitem()
play_pause = Dbusmenu.Menuitem()
play_pause.property_set(Dbusmenu.MENUITEM_PROP_LABEL,
_("Play/Pause"))
play_pause.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
main.child_append(play_pause)
def play_pause_cb(item, timestamp):
player.playpause()
play_pause.connect("item-activated", play_pause_cb)
next_ = Dbusmenu.Menuitem()
next_.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Next"))
next_.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
main.child_append(next_)
def next_cb(item, timestamp):
player.next()
next_.connect("item-activated", next_cb)
prev = Dbusmenu.Menuitem()
prev.property_set(Dbusmenu.MENUITEM_PROP_LABEL, _("Previous"))
prev.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True)
main.child_append(prev)
def prev_cb(item, timestamp):
player.previous()
prev.connect("item-activated", prev_cb)
launcher.set_property("quicklist", main)
|
jacksarick/My-Code
|
Events/CCC/2015/J4.py
|
Python
|
mit
| 601
| 0.021631
|
#Problem J4: Wait Time
inputarray = []
for i in range(input()):
inputarray.append(raw_input().split(" "))
#Number, total, lastwait, response
friendarray = []
ctime = 0
for i in range(len(inpu
|
tarray)):
if inputarray[i][0].lower() == "c":
ctime += inputarray[i][1]
if inputarray[i][0].lower() == "r":
friendlist = [friendarray[j][0] for j in range(len(friendarray))]
if (inputarray[i][1] not in friendlist):
friendarray.append([inputarray[i][0].lower(), 0, ])
else:
|
location = friendlist.index(inputarray[i][1])
friendarray[location] = [inputarray[i][1], friendarray[location] + ]
|
alemonmk/pytgasu
|
pytgasu/upload/defparse.py
|
Python
|
gpl-3.0
| 2,873
| 0.001044
|
# pytgasu - Automating creation of Telegram sticker packs
# Copyright (C) 2017 Lemon Lam <[email protected]>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from ..constants import *
__all__ = ['parse']
def parse(def_file):
"""
Parse specified sticker set definition file.
:param def_file: A Path-like object to .ssd file
:return: A tuple of set_title, set_short_name, [(image_fullpath, emojis)] representing the set
None on error
"""
import re
_sticker_line_pattern = re.compile(REGEX_MATCHING_EMOJI)
try:
with open(def_file, encoding='utf-8', errors='strict') as f:
lines = [l.rstrip() for l in f] # strip line breaks
except ValueError:
print(ERROR_DEFFILE_ENCODING % def_file)
else:
set_title = lines[0]
set_short_name = lines[1]
stickers = list() # there may be a 120 stickers per set hard limit, idk
for sticker_line in lines[2:]:
if not _sticker_line_pattern.fullmatch(sticker_line):
print(ERROR_INCORRECT_STICKER_LINE % sticker_line)
continue
image_filename, emoji_seq = sticker_line.split('/')
|
image_path = def_file.with_name(image_filename)
if not _validate_image(image_path):
continue
if not emoji_seq:
emoji_seq = DEFAULT_EMOJI
|
stickers.append((image_path, emoji_seq))
if not stickers:
print(ERROR_NO_STICKER_IN_SET)
return None
return set_title, set_short_name, stickers
def _validate_image(image_path):
"""
Check file existence, image is correct PNG,
dimension is 512x? or ?x512 and file size < 512KB
:param image_path: The image for a sticker
:return: Boolean if all limits on stickers met
"""
from PIL.Image import open as pil_open
try:
with pil_open(image_path) as image:
criteria = [
max(image.size) == 512,
image.format == 'PNG',
image_path.stat().st_size < 512 * 1000
]
return True if all(criteria) else False
except IOError:
print(ERROR_INVAILD_STICKER_IMAGE % image_path.name)
return False # not a picture or just 404
|
PythonProgramming/Pandas-Basics-with-2.7
|
pandas 5 - Column Operations (Basic mathematics, moving averages).py
|
Python
|
mit
| 416
| 0.009615
|
import pandas as pd
from pandas import DataFrame
df = pd.read_csv('sp500_ohlc.csv', index_col = 'Date', parse
|
_dates=True)
#notice what i did, since it is an object
df[
|
'H-L'] = df.High - df.Low
print df.head()
df['100MA'] = pd.rolling_mean(df['Close'], 100)
# must do a slice, since there will be no value for 100ma until 100 points
print df[200:210]
df['Difference'] = df['Close'].diff()
print df.head()
|
regular/talkshow
|
wrappers.py
|
Python
|
gpl-3.0
| 20,806
| 0.01341
|
import weakref
from sys import getrefcount
import string
import talkshowConfig
style = talkshowConfig.config().parser.style
from talkshowLogger import logger
debug = logger.debug
info = logger.info
warn = logger.warn
#?? pyglet.options['audio'] = ('directsound', 'openal', 'silent')
from pyglet.gl import *
from pyglet.media import *
from rect import *
from animated_property import AnimatedProperty
class Visible(object):
instanceCount = 0
def __init__(self, p, name, x=0, y=0, w=10, h=10):
self.x = x
self.y = y
self.w = w
self.h = h
self.name = name
self.__parent__ = None
self.setParent(p)
self.__class__.instanceCount += 1
def __del__(self):
self.__class__.instanceCount -= 1
def getParent(self):
if self.__parent__ == None: return None
return self.__parent__()
def setParent(self, newParent):
if self.__parent__ != None:
if self.__parent__() == newParent:
return
else:
if newParent == None:
return
if newParent != None:
newParent.__addChild__(self)
if self.__parent__ != None:
self.__parent__().__removeChild__(self)
if newParent != None:
self.__parent__ = weakref.ref(newParent)
else:
self.__parent__ = None
parent = property(getParent, setParent)
def contains(self, x, y):
if x >= self.x and y >= self.y and x < self.x + self.w and y < self.y + self.h:
return True
else:
return False
def _getPosition(self): return (self.x, self.y)
def _setPosition(self, value): self.x, self.y = value
position = property(_getPosition, _setPosition)
def _getExtent(self): return (self.w, self.h)
def _setExtent(self, value): self.w, self.h = value
extent = property(_getExtent, _setExtent)
def draw(self):
pass
def animate(self, propname, startvalue, endvalue, when, duration = 0, flags = 0):
if propname != "color":
AnimatedProperty.animate(self, propname, startvalue, endvalue, when, duration, flags)
else:
self._color_fade_value1 = splitColorChannels(startvalue)
self._color_fade_value2 = splitColorChannels(endvalue)
self._color_fade = 0.0
AnimatedProperty.animate(self, "_color_fade", 0.0, 1.0, when, duration, flags)
def splitColorChannels(c):
return (
string.atoi(c[1:3], 16) / 255.0,
string.atoi(c[3:5], 16) / 255.0,
string.atoi(c[5:7], 16) / 255.0
)
def mergeColorChannels(r,g,b):
return "#%2.2X%2.2X%2.2X" % (r*255,g*255,b*255)
class ColoredVisible(Visible):
instanceCount = 0
def __init__(self, p, name, x=0, y=0, w=0, h=0, color="#00ff00", opacity=1.0):
Visible.__init__(self, p, name, x, y, w, h)
self.color = color
self.opacity = opacity
def _setColor(self, c):
self.r, self.g, self.b = splitColorChannels(c)
def _getColor(self):
return mergeColorChannels(self.r, self.g, self.b)
color = property(_getColor, _setColor)
def _setCOLORFADE(self, cf):
self._COLORFADE= cf
r1, g1, b1 = self._color_fade_value1
r2, g2, b2 = self._color_fade_value2
self.r = r1 + (r2 - r1) * cf
self.g = g1 + (g2 - g1) * cf
self.b = b1 + (b2 - b1) * cf
def _getCOLORFADE(self):
return self._COLORFADE
_color_fade = property(_getCOLORFADE, _setCOLORFADE)
class Rect(ColoredVisible):
instanceCount = 0
def __init__(self, p, name, x=0, y=0, w=0, h=0, color="#00ff00", opacity=1.0):
ColoredVisible.__init__(self, p, name, x, y, w, h, color, opacity)
def draw(self):
#glColor3f(self.r,self.g,self.b)
pyglet.graphics.draw_indexed(4, pyglet.gl.GL_TRIANGLES,
[0, 1, 2, 0, 2, 3],
('v2f', (float(self.x), float(self.y),
float(self.x+self.w), float(self.y),
float(self.x+self.w), float(self.y+self.h),
float(self.x), float(self.y+self.h))),
('c4f', (self.r, self.g, self.b, self.opacity)*4)
)
class Screen(ColoredVisible):
def __init__(self, name, device = "", w = 800, h = 600, color=style.page.background_color):
try:
fullscreen = bool(talkshowConfig.fullScreen)
except:
fullscreen = False
self.window = pyglet.window.Window(caption=name, fullscreen=fullscreen, resizable=True)
if not fullscreen:
self.window.set_size(w, h)
##?? self.window.push_handlers(pyglet.window.event.WindowEventLogger())
ColoredVisible.__init__(self, None, name, 0, 0, self.w, self.h, color, opacity=1.0)
self.__children__ = []
self.event_handler = None
@self.window.event
def on_resize(width, height):
self.extent = width, heig
|
ht
glViewport(0, 0, width, height)
glMatrixMode(gl.GL_PROJECTION)
glLoadIdentity()
gluOrtho2D(0, width, 0, height);
glScalef(1, -1, 1);
glTranslatef(0, -height, 0);
glMatrixMode(gl.GL_MODELVIEW)
h = self.getHandlerMethod("onResize")
if h: h(width, height)
|
self.window.on_resize = on_resize
@self.window.event
def on_draw():
self.window.clear()
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_BLEND)
for x in self.__children__:
x.draw()
glDisable(GL_BLEND)
buttonLUT = {
pyglet.window.mouse.LEFT: "left",
pyglet.window.mouse.MIDDLE: "middle",
pyglet.window.mouse.RIGHT: "right",
}
@self.window.event
def on_mouse_motion(x, y, dx, dy):
y = self.h - y
h = self.getHandlerMethod("onMouseMove")
if h: h(x, y)
@self.window.event
def on_mouse_press(x, y, button, modifiers):
y = self.h - y
h = self.getHandlerMethod("onMouseButtonDown")
if h: h(buttonLUT[button], x, y)
@self.window.event
def on_mouse_release(x, y, button, modifiers):
y = self.h - y
h = self.getHandlerMethod("onMouseButtonUp")
if h: h(buttonLUT[button], x, y)
@self.window.event
def on_mouse_drag(x, y, dx, dy, buttons, modifiers):
# we use the same handler as for mouse move
y = self.h - y
h = self.getHandlerMethod("onMouseMove")
if h: h(x, y)
#@self.window.event
#def on_mouse_scroll(x, y, scroll_x, scroll_y):
def getHandlerMethod(self, name):
if self.event_handler != None:
if hasattr(self.event_handler, name):
return getattr(self.event_handler, name)
return None
def __addChild__(self, c):
if not c in self.__children__:
self.__children__.append(c)
def __removeChild__(self, c):
self.__children__.remove(c)
def __iter__(self):
return self.__children__.__iter__()
def __len__(self):
return len(self.__children__)
def getW(self): return self.window.width
def setW(self, w):
if w != self.window.width:
self.window.width = w
w = property(getW, setW)
def getH(self): return self.window.height
def setH(self, h):
if h != self.window.height:
self.window.height = h
h = property(getH, setH)
class Image(ColoredVisible):
def __init__(self, p, name, path, x=0, y=0, w=None, h=None, color="#ffffff", opacity=1.0):
debug(path)
if path:
image = pyglet.image.load(path)
|
blindsightcorp/rigor-webapp
|
plugins/percept_search_page/__init__.py
|
Python
|
bsd-2-clause
| 9,018
| 0.028055
|
from __future__ import division
import json
import urllib
from flask import request
from flask import render_template
from flask import abort
import jinja2
import rigor.config
import rigorwebapp.plugin
import rigorwebapp.utils
from rigorwebapp.utils import debug_detail, debug_main, debug_error
import rigorwebapp.auth
kPluginName = 'percept_search_page'
AuthClient = rigorwebapp.auth.DefaultAuthClient()
class PerceptSearchPagePlugin(rigorwebapp.plugin.BasePlugin):
def __init__(self, backend, rigor_config):
self.rigor_config = rigor_config
self.backend = backend
try:
self.thumbnail_size_max = int(rigor_config.get("webapp","thumbnail_size_max"))
except rigor.config.NoValueError:
self.thumbnail_size_max = 128
try:
self.results_per_page = int(rigor_config.get("webapp","percept_search_page_results_per_page"))
except rigor.config.NoValueError:
self.results_per_page = 30
def add_routes(self, app, backend, plugin_instances):
@app.route('/db/<db_name>/perceptsearch')
@AuthClient.check_access_and_inject_user(self.rigor_config)
def percept_search_page(db_name, username=None):
if not db_name in backend.db_names():
abort(404)
# clean up search params
search_params = request.args.to_dict()
search_params['page'] = max(1, int(search_params.get('page', 1))) # human-readable page number starts at 1, not 0
for int_param in ['random_nth', 'random_out_of']:
if int_param in search_params:
search_params[int_param] = int(search_params[int_param])
param_whitelist = """
page
device_id
collection_id
hash
annotation_domain
annotation_model
annotation_property
percept_property
locator
random_nth
random_out_of
""".strip().split()
for key in list(search_params.keys()):
if not key in param_whitelist:
del search_params[key]
if search_params[key] == '':
del search_params[key]
search_results, total_count = backend.search_percepts(db_name=db_name, query=search_params, per_page=self.results_per_page, load_paths='tags')
page_state = {
'current_view': kPluginName,
'username': username,
kPluginName: dict(
db_name=db_name,
db_names=backend.db_names(),
search_results=search_results,
total_count=total_count,
per_page=self.results_per_page,
num_pages=int(total_count / self.results_per_page + 1),
search_params=search_params,
),
}
template_slots = rigorwebapp.plugin.TemplateSlots()
rigorwebapp.plugin.augment_request(plugin_instances, page_state, template_slots)
return render_template('standard_template.html', page_state=page_state, template_slots=template_slots)
def augment_page_state(self, page_state):
pass
def augment_template_slots(self, page_state, template_slots):
# add to navbar on all pages
# first, figure out db_name
try:
db_name = page_state[page_state['current_view']]['db_name']
except KeyError:
try:
db_name = self.rigor_config.get("webapp", "initial_db")
except rigor.config.NoValueError:
db_name='?'
navbar_url = '/db/{}/perceptsearch'.format(db_name)
template_slots.append('navbar_link', '<a href="{}">Percept Search</a>'.format(navbar_url))
# if this isn't our own page, stop here
if page_state['current_view'] != kPluginName:
return
template_slots.append('js_tail_path', '/static/plugins/percept_search_page/js/index.js')
template_slots.append('css_path', '/static/plugins/percept_search_page/css/index.css')
# build next/prev links for pagination navigation
prev_link = None
next_link = None
page = page_state[kPluginName]['search_params']['page']
prev_params = page_state[kPluginName]['search_params'].copy()
prev_params['page'] -= 1
next_params = page_state[kPluginName]['search_params'].copy()
next_params['page'] += 1
if prev_params['page'] >= 1:
prev_link = 'perceptsearch?' + urllib.urlencode(prev_params)
if next_params['page'] <= page_state[kPluginName]['num_pages']:
next_link = 'perceptsearch?' + urllib.urlencode(next_params)
template_slots.append('main_panel_pager_bar', dict(
prev_link=prev_link,
next_link=next_link,
num_results=page_state[kPluginName]['total_count'],
page_num=page,
num_pages=page_state[kPluginName]['num_pages']
))
thumb_grid_template = """
{% for percept in search_results %}
<div class="searchResult">
<a href="/db/{{db_name}}/percept/{{'{}'.format(percept.id)}}">
{% if percept.x_size and percept.y_size: %}
<img class="searchResultImg" src="{{percept.img_url+'?max_size='}}{{thumbnail_size_max}}" width="{{thumbsize(percept.x_size, percept.y_size)[0]}}" height="{{thumbsize(percept.x_size, percept.y_size)[1]}}" />
{% else %}
<div class="missingImage" style="height:{{thumbnail_size_max}}px; width:{{thumbnail_size_max}}px; display: block;"></div>
{% endif %}
</a>
<div class="searchResultCaption">
{% for tag in percept.tags %}
<div class="tag"
style="background: hsl({{tag_to_hue(tag)}}, 25%, 50%)"
>
{{tag}}
</div>
{% endfor %}
</div>
</div>
{% endfor %}
"""
thumb_grid_template_context = dict(
thumbsize = lambda width,height,maxsize=self.thumbnail_size_max: self.backend.percept_image_scaled_size((width,height),int(maxsize)),
tag_to_hue = rigorwebapp.utils.hash_string_to_hue,
thumbnail_size_max = self.thumbnail_size_max,
**page_state[kPluginName]
)
template_slots.append('main_panel', jinja2.Template(thumb_grid_template).render(thumb_grid_template_context))
search_form_template = """
<div class="sidebarTitle">
|
Search
</div>
<form id="perceptSearchForm">
<div class="searchFormRow">
<div class="searchFormRowLabel">
Database
</
|
div>
<select class="searchFormSelect" id="perceptSearchFormDbSelect">
{% for this_db_name in db_names %}
{% if this_db_name == db_name %}
<option value={{this_db_name}} selected>{{this_db_name}}</option>
{% else %}
<option value={{this_db_name}}>{{this_db_name}}</option>
{% endif %}
{% endfor %}
</select>
</div>
{% for facet in facets %}
<div class="searchFormRow">
<div class="searchFormRowLabel">{{facet.caption}}</div>
{% if facet.get('help_text') %}
<div class="searchFormRowHelp">{{facet.help_text}}</div>
{% endif %}
<input style="width:100%" type="text" id="{{facet.dom_id}}" value="{{facet.value}}"/>
</div>
{% endfor %}
<div class="searchFormRow">
<div class="searchFormRowLabel">Random subset</div>
<span class="searchFormRowHelp">The </span>
<input style="width:15%" type="text" id="perceptSearchFormRandomNth" value="{{random_nth_value}}"/>
<span class="searchFormRowHelp">th percept out of each</span>
<input style="width:15%" type="text" id="perceptSearchFormRandomOutOf" value="{{random_out_of_value}}"/>
</div>
<div class="searchFormButtonRow">
<input class="button" type="submit" value="Search"/>
</div>
</form>
"""
search_params = page_state[kPluginName]['search_params']
search_form_template_context = page_state[kPluginName].copy()
search_form_template_context['random_nth_value'] = search_params.get('random_nth', '')
search_form_template_context['random_out_of_value'] = search_params.get('random_out_of', '')
search_form_template_context['facets'] = [
dict(
dom_id='perceptSearchFormLocator',
value=search_params.get('locator', ''),
caption='Locator',
help_text='Use "*" as a wildcard.',
),
dict(
dom_id='perceptSearchFormCollectionId',
value=search_params.get('collection_id', ''),
caption='Collection ID',
),
dict(
dom_id='perceptSearchFormDeviceId',
value=search_params.get('device_id', ''),
caption='Device ID',
),
dict(
dom_id='perceptSearchFormHash',
value=search_params.get('hash', ''),
caption='Percept hash',
),
dict(
dom_id='perceptSearchFormAnnotationDomain',
value=search_params.get('annotation_domain', ''),
caption='Annotation domain',
),
dict(
dom_id='perceptSearchFormAnnotationModel',
value
|
sheimi/os-benchmark
|
script/analysis/analysis.py
|
Python
|
gpl-3.0
| 3,736
| 0.005621
|
#!/usr/bin/env python
from os import path
from collections import defaultdict
import math
root = path.dirname(path.dirname(path.dirname(__file__)))
result_dir = path.join(root, 'results')
def get_file_name(test):
test = '%s_result' % test
return path.join(result_dir, test)
def mean(l):
return float(sum(l))/len(l) if len(l) > 0 else float('nan')
def std_dev(l):
m = mean(l)
return math.sqrt(sum((x - m) ** 2 for x in l) / len(l))
def run_timing_overhead_ana():
test_name = 'timing_overhead'
file_name = get_file_name(test_name)
datas = []
with open(file_name) as f:
for l in f:
datas.append(int(l))
datas = [i for i in datas[:10000]]
print "%s mean: %f" % (test_name, mean(datas))
print "%s std dev: %f" % (test_name, std_dev(datas))
def run_loop_overhead_ana():
test_name = 'loop_overhead'
file_name = get_file_name(test_name)
datas = []
with open(file_name) as f:
for l in f:
datas.append(float(l
|
.split(' ')[0]))
datas = [i for i in datas[:10000]]
print "%s mean: %f" % (test_name, mean(datas))
print "%s std dev: %f" % (test_name, std_dev(datas))
def run_proc_call_overhead_ana():
test_na
|
me = 'proc_call_overhead'
file_name = get_file_name(test_name)
datas = []
with open(file_name) as f:
for l in f:
if l.startswith('-'):
datas.append([])
continue
datas[-1].append(int(l.split(' ')[0]) * 1.0 / 10)
print "%s result:" % test_name
for i, data in enumerate(datas):
m = mean(data)
std = std_dev(data)
print "%f\t%f" % (m, std)
#print "%s %d mean: %f" % (test_name, i, mean(data))
#print "%s %d std dev: %f" % (test_name, i, std_dev(data))
def run_process_context_switch_ana():
test_name = 'process_context_switch'
file_name = get_file_name(test_name)
datas = []
with open(file_name) as f:
for l in f:
try:
datas.append(int(l.split(' ')[1]))
except:
pass
datas = [i for i in datas[:100]]
print "%s mean: %f" % (test_name, mean(datas))
print "%s std dev: %f" % (test_name, std_dev(datas))
def run_thread_context_switch_ana():
test_name = 'thread_context_switch'
file_name = get_file_name(test_name)
datas = []
with open(file_name) as f:
for l in f:
datas.append(int(l.split(' ')[1]))
datas = [i for i in datas[:100]]
print "%s mean: %f" % (test_name, mean(datas))
print "%s std dev: %f" % (test_name, std_dev(datas))
def run_mem_acc_ana():
test_name = 'mem_acc'
filename = get_file_name(test_name)
datas = defaultdict(lambda: defaultdict(list))
with open(filename) as f:
for l in f:
ll = l.split(' ')
step = int(ll[7])
offset = int(ll[1])
cycle = float(ll[3])
datas[step][offset].append(cycle)
results = {}
offsets = set()
for step, v in sorted(datas.items()):
result = []
for offset, cycles in sorted(v.items()):
offsets.add(offset)
m = mean(cycles)
result.append(m)
results[step] = (result)
print "mem access time result"
fl = "step/offset\t%s" % "\t".join(str(i) for i in sorted(offsets))
print fl
for step, means in sorted(results.items()):
line = "\t".join(str(i) for i in means)
line = "%s\t%s" % (str(step), line)
print line
if __name__ == '__main__':
run_timing_overhead_ana()
run_loop_overhead_ana()
run_proc_call_overhead_ana()
run_process_context_switch_ana()
run_thread_context_switch_ana()
run_mem_acc_ana()
|
pschmitt/home-assistant
|
homeassistant/components/airly/air_quality.py
|
Python
|
apache-2.0
| 3,907
| 0.000768
|
"""Support for the Airly air_quality service."""
from homeassistant.components.air_quality import (
ATTR_AQI,
ATTR_PM_2_5,
ATTR_PM_10,
AirQualityEntity,
)
from homeassistant.const import CONF_NAME
from .const import (
ATTR_API_ADVICE,
ATTR_API_CAQI,
ATTR_API_CAQI_DESCRIPTION,
ATTR_API_CAQI_LEVEL,
ATTR_API_PM10,
ATTR_API_PM10_LIMIT,
ATTR_API_PM10_PERCENT,
ATTR_API_PM25,
ATTR_API_PM25_LIMIT,
ATTR_API_PM25_PERCENT,
DOMAIN,
)
ATTRIBUTION = "Data provided by Airly"
LABEL_ADVICE = "advice"
LABEL_AQI_DESCRIPTION = f"{ATTR_AQI}_description"
LABEL_AQI_LEVEL = f"{ATTR_AQI}_level"
LABEL_PM_2_5_LIMIT = f"{ATTR_PM_2_5}_limit"
LABEL_PM_2_5_PERCENT = f"{ATTR_PM_2_5}_percent_of_limit"
LABEL_PM_10_LIMIT = f"{ATTR_PM_10}_limit"
LABEL_PM_10_PERCENT = f"{ATTR_PM_10}_percent_of_limit"
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up Airly air_quality entity based on a config entry."""
name = config_entry.data[CONF_NAME]
coordinator = hass.data[DOMAIN][config_entry.entry_id]
async_add_entities(
[AirlyAirQuality(coordinator, name, config_entry.unique_id)], False
)
def rou
|
nd_state(func):
"""Round state."""
def _decorator(self):
|
res = func(self)
if isinstance(res, float):
return round(res)
return res
return _decorator
class AirlyAirQuality(AirQualityEntity):
"""Define an Airly air quality."""
def __init__(self, coordinator, name, unique_id):
"""Initialize."""
self.coordinator = coordinator
self._name = name
self._unique_id = unique_id
self._icon = "mdi:blur"
@property
def name(self):
"""Return the name."""
return self._name
@property
def should_poll(self):
"""Return the polling requirement of the entity."""
return False
@property
def icon(self):
"""Return the icon."""
return self._icon
@property
@round_state
def air_quality_index(self):
"""Return the air quality index."""
return self.coordinator.data[ATTR_API_CAQI]
@property
@round_state
def particulate_matter_2_5(self):
"""Return the particulate matter 2.5 level."""
return self.coordinator.data[ATTR_API_PM25]
@property
@round_state
def particulate_matter_10(self):
"""Return the particulate matter 10 level."""
return self.coordinator.data[ATTR_API_PM10]
@property
def attribution(self):
"""Return the attribution."""
return ATTRIBUTION
@property
def unique_id(self):
"""Return a unique_id for this entity."""
return self._unique_id
@property
def available(self):
"""Return True if entity is available."""
return self.coordinator.last_update_success
@property
def device_state_attributes(self):
"""Return the state attributes."""
return {
LABEL_AQI_DESCRIPTION: self.coordinator.data[ATTR_API_CAQI_DESCRIPTION],
LABEL_ADVICE: self.coordinator.data[ATTR_API_ADVICE],
LABEL_AQI_LEVEL: self.coordinator.data[ATTR_API_CAQI_LEVEL],
LABEL_PM_2_5_LIMIT: self.coordinator.data[ATTR_API_PM25_LIMIT],
LABEL_PM_2_5_PERCENT: round(self.coordinator.data[ATTR_API_PM25_PERCENT]),
LABEL_PM_10_LIMIT: self.coordinator.data[ATTR_API_PM10_LIMIT],
LABEL_PM_10_PERCENT: round(self.coordinator.data[ATTR_API_PM10_PERCENT]),
}
async def async_added_to_hass(self):
"""Connect to dispatcher listening for entity data notifications."""
self.async_on_remove(
self.coordinator.async_add_listener(self.async_write_ha_state)
)
async def async_update(self):
"""Update Airly entity."""
await self.coordinator.async_request_refresh()
|
sandrafig/addons
|
calendar_event_meeting_reason/models/calendar_event.py
|
Python
|
agpl-3.0
| 488
| 0.004098
|
# -*- coding: utf-8 -*-
from openerp import models, fields, api
class CalendarEvent(models.Model):
_inherit = 'calendar.event'
meeting_reason_id = fields.Many2one(
'calendar.event.meeting.reason',
|
string="Meeting reason",
ondelete="restrict")
class
|
CalendarEventMeetingReason(models.Model):
_name = 'calendar.event.meeting.reason'
_description = 'Calendar Event Meeting Reason'
name = fields.Char('Reason', required=False, translate=True)
|
engineer0x47/SCONS
|
engine/SCons/Tool/mwcc.py
|
Python
|
mit
| 6,841
| 0.003947
|
"""SCons.Tool.mwcc
Tool-specific initialization for the Metrowerks CodeWarrior compiler.
There normally shouldn't be any need to import this module directly.
It will usually be imported through the generic SCons.Tool.Tool()
selection method.
"""
#
# Copyright (c) 2001 - 2014 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
__revision__ = "src/engine/SCons/Tool/mwcc.py 2014/08/24 12:12:31 garyo"
import os
import os.path
import SCons.Util
def set_vars(env):
"""Set MWCW_VERSION, MWCW_VERSIONS, and some codewarrior environment vars
MWCW_VERSIONS is set to a list of objects representing installed versions
MWCW_VERSION is set to the version object that will be used for building.
MWCW_VERSION can be set to a string during Environment
construction to influence which version is chosen, otherwise
the latest one from MWCW_VERSIONS is used.
Returns true if at least one version is found, false otherwise
"""
desired = env.get('MWCW_VERSION', '')
# return right away if the variables are already set
if isinstance(desired, MWVersion):
return 1
elif desired is None:
return 0
versions = find_versions()
version = None
if desired:
for v in versions:
if str(v) == desired:
version = v
elif versions:
version = versions[-1]
env['MWCW_VERSIONS'] = versions
env['MWCW_VERSION'] = version
if version is None:
return 0
env.PrependENVPath('PATH', version.clpath)
env.PrependENVPath('PATH', version.dllpath)
ENV = env['ENV']
ENV['CWFolder'] = version.path
ENV['LM_LICENSE_FILE'] = version.license
plus = lambda x: '+%s' % x
ENV['MWCIncludes'] = os.pathsep.join(map(plus, version.includes))
ENV['MWLibraries'] = os.pathsep.join(map(plus, version.libs))
return 1
def find_versions():
"""Return a list of MWVersion objects representing installed versions"""
versions = []
#
|
## This function finds CodeWarrior by reading from the registry on
### Windows. Some other method needs to be implemented for other
### platforms, maybe something that calls
|
env.WhereIs('mwcc')
if SCons.Util.can_read_reg:
try:
HLM = SCons.Util.HKEY_LOCAL_MACHINE
product = 'SOFTWARE\\Metrowerks\\CodeWarrior\\Product Versions'
product_key = SCons.Util.RegOpenKeyEx(HLM, product)
i = 0
while True:
name = product + '\\' + SCons.Util.RegEnumKey(product_key, i)
name_key = SCons.Util.RegOpenKeyEx(HLM, name)
try:
version = SCons.Util.RegQueryValueEx(name_key, 'VERSION')
path = SCons.Util.RegQueryValueEx(name_key, 'PATH')
mwv = MWVersion(version[0], path[0], 'Win32-X86')
versions.append(mwv)
except SCons.Util.RegError:
pass
i = i + 1
except SCons.Util.RegError:
pass
return versions
class MWVersion(object):
def __init__(self, version, path, platform):
self.version = version
self.path = path
self.platform = platform
self.clpath = os.path.join(path, 'Other Metrowerks Tools',
'Command Line Tools')
self.dllpath = os.path.join(path, 'Bin')
# The Metrowerks tools don't store any configuration data so they
# are totally dumb when it comes to locating standard headers,
# libraries, and other files, expecting all the information
# to be handed to them in environment variables. The members set
# below control what information scons injects into the environment
### The paths below give a normal build environment in CodeWarrior for
### Windows, other versions of CodeWarrior might need different paths.
msl = os.path.join(path, 'MSL')
support = os.path.join(path, '%s Support' % platform)
self.license = os.path.join(path, 'license.dat')
self.includes = [msl, support]
self.libs = [msl, support]
def __str__(self):
return self.version
CSuffixes = ['.c', '.C']
CXXSuffixes = ['.cc', '.cpp', '.cxx', '.c++', '.C++']
def generate(env):
"""Add Builders and construction variables for the mwcc to an Environment."""
import SCons.Defaults
import SCons.Tool
set_vars(env)
static_obj, shared_obj = SCons.Tool.createObjBuilders(env)
for suffix in CSuffixes:
static_obj.add_action(suffix, SCons.Defaults.CAction)
shared_obj.add_action(suffix, SCons.Defaults.ShCAction)
for suffix in CXXSuffixes:
static_obj.add_action(suffix, SCons.Defaults.CXXAction)
shared_obj.add_action(suffix, SCons.Defaults.ShCXXAction)
env['CCCOMFLAGS'] = '$CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -nolink -o $TARGET $SOURCES'
env['CC'] = 'mwcc'
env['CCCOM'] = '$CC $CFLAGS $CCFLAGS $CCCOMFLAGS'
env['CXX'] = 'mwcc'
env['CXXCOM'] = '$CXX $CXXFLAGS $CCCOMFLAGS'
env['SHCC'] = '$CC'
env['SHCCFLAGS'] = '$CCFLAGS'
env['SHCFLAGS'] = '$CFLAGS'
env['SHCCCOM'] = '$SHCC $SHCFLAGS $SHCCFLAGS $CCCOMFLAGS'
env['SHCXX'] = '$CXX'
env['SHCXXFLAGS'] = '$CXXFLAGS'
env['SHCXXCOM'] = '$SHCXX $SHCXXFLAGS $CCCOMFLAGS'
env['CFILESUFFIX'] = '.c'
env['CXXFILESUFFIX'] = '.cpp'
env['CPPDEFPREFIX'] = '-D'
env['CPPDEFSUFFIX'] = ''
env['INCPREFIX'] = '-I'
env['INCSUFFIX'] = ''
#env['PCH'] = ?
#env['PCHSTOP'] = ?
def exists(env):
return set_vars(env)
# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4:
|
basp/neko
|
spikes/main.py
|
Python
|
mit
| 2,241
| 0.002231
|
# Permission to use, copy, modify, and/or distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import libtcodpy as libtcod
import tokenizer
import match
import textfield
import textview
import command
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 35
FONT_FLAGS = libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD
FONT_FILE = 'fonts/dejavu12x12_gs_tc.png'
LIMIT_FPS = 25
TITLE = 'Neko (lost kitty)'
text_field = textfield.TextField(0, SCREEN_HEIGHT - 1, SCREEN_WIDTH, 1)
text_view = textview.TextView(
|
0, 0, SCREEN_WIDTH, SCREEN_HEIGHT - 1)
builtins = {'me': 123} # $tags: stub, example, todo
def eval_str(s, globals):
try:
r = eval(s, globals)
return str(r)
except Exception as e
|
:
return str(e)
def on_command(sender, args):
if args.key.vk != libtcod.KEY_ENTER:
return
s = text_field.get_text()
if match.starts_with(';', s):
r = eval_str(s[1:], builtins)
text_view.lines.append(str(r))
else:
tokens = tokenizer.tokenize(s)
cmd = command.parse(tokens)
text_view.lines.append(str(tokens))
text_view.lines.append(str(cmd))
text_field.add_handler(on_command)
libtcod.sys_set_fps(LIMIT_FPS)
libtcod.console_set_custom_font(FONT_FILE, FONT_FLAGS)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, TITLE, False)
while not libtcod.console_is_window_closed():
libtcod.console_set_default_foreground(0, libtcod.white)
libtcod.console_clear(0)
text_field.render(0)
text_view.render(0)
libtcod.console_flush()
key = libtcod.console_check_for_keypress(libtcod.KEY_PRESSED)
text_field.update(key)
|
itbabu/django-oscar
|
src/oscar/apps/catalogue/admin.py
|
Python
|
bsd-3-clause
| 3,190
| 0
|
from django.contrib import admin
from treebeard.admin import TreeAdmin
from treebeard.forms import movenodeform_factory
from oscar.core.loading import get_model
AttributeOption = get_model('catalogue', 'AttributeOption')
AttributeOptionGroup = get_model('catalogue', 'AttributeOptionGroup')
Category = get_model('catalogue', 'Category')
Option = get_model('catalogue', 'Option')
Product = get_model('catalogue', '
|
Product')
ProductAttribute = get_model('catalogue', 'ProductAttribute')
ProductAttributeValue = get_model('catalogue', 'ProductAttributeValue')
ProductCategory = get_model('catalogue', 'ProductCategory')
ProductClass = get_model('catalogue', 'ProductClass')
ProductImage = get_model('catalogue', 'ProductImage')
P
|
roductRecommendation = get_model('catalogue', 'ProductRecommendation')
class AttributeInline(admin.TabularInline):
model = ProductAttributeValue
class ProductRecommendationInline(admin.TabularInline):
model = ProductRecommendation
fk_name = 'primary'
raw_id_fields = ['primary', 'recommendation']
class CategoryInline(admin.TabularInline):
model = ProductCategory
extra = 1
class ProductAttributeInline(admin.TabularInline):
model = ProductAttribute
extra = 2
class ProductClassAdmin(admin.ModelAdmin):
list_display = ('name', 'requires_shipping', 'track_stock')
inlines = [ProductAttributeInline]
class ProductAdmin(admin.ModelAdmin):
date_hierarchy = 'date_created'
list_display = ('get_title', 'upc', 'get_product_class', 'structure',
'attribute_summary', 'date_created')
list_filter = ['structure', 'is_discountable']
raw_id_fields = ['parent']
inlines = [AttributeInline, CategoryInline, ProductRecommendationInline]
prepopulated_fields = {"slug": ("title",)}
search_fields = ['upc', 'title']
def get_queryset(self, request):
qs = super(ProductAdmin, self).get_queryset(request)
return (
qs
.select_related('product_class', 'parent')
.prefetch_related(
'attribute_values',
'attribute_values__attribute'))
class ProductAttributeAdmin(admin.ModelAdmin):
list_display = ('name', 'code', 'product_class', 'type')
prepopulated_fields = {"code": ("name", )}
class OptionAdmin(admin.ModelAdmin):
pass
class ProductAttributeValueAdmin(admin.ModelAdmin):
list_display = ('product', 'attribute', 'value')
class AttributeOptionInline(admin.TabularInline):
model = AttributeOption
class AttributeOptionGroupAdmin(admin.ModelAdmin):
list_display = ('name', 'option_summary')
inlines = [AttributeOptionInline, ]
class CategoryAdmin(TreeAdmin):
form = movenodeform_factory(Category)
admin.site.register(ProductClass, ProductClassAdmin)
admin.site.register(Product, ProductAdmin)
admin.site.register(ProductAttribute, ProductAttributeAdmin)
admin.site.register(ProductAttributeValue, ProductAttributeValueAdmin)
admin.site.register(AttributeOptionGroup, AttributeOptionGroupAdmin)
admin.site.register(Option, OptionAdmin)
admin.site.register(ProductImage)
admin.site.register(Category, CategoryAdmin)
admin.site.register(ProductCategory)
|
lezzago/LambdaMart
|
RegressionTree.py
|
Python
|
mit
| 6,591
| 0.038082
|
# regression tree
# input is a dataframe of features
# the corresponding y value(called labels here) is the scores for each document
import pandas as pd
import numpy as np
from multiprocessing import Pool
from itertools import repeat
import scipy
import scipy.optimize
node_id = 0
def get_splitting_points(args):
# given a list
# return a list of possible splitting values
attribute, col = args
attribute.sort()
possible_split = []
for i in range(len(attribute)-1):
if attribute[i] != attribute[i+1]:
possible_split.append(np.mean((attribute[i],attribute[i+1])))
return possible_split, col
# create a dictionary, key is the attribute number, value is whole list of possible splits for that column
def find_best_split_parallel(args):
best_ls = 1000000
best_split = None
best_children = None
split_point, data, label = args
key,possible_split = split_point
for split in possible_split:
children = split_children(data, label, key, split)
#weighted average of left and right ls
ls = len(children[1])*least_square(children[1])/len(label) + len(children[3])*least_square(children[3])/len(label)
if ls < best_ls:
best_ls = ls
best_split = (key, split)
best_children = children
return best_ls, best_split, best_children
def find_best_split(data, label, split_points):
# split_points is a dictionary of possible splitting values
# return the best split
best_ls = 1000000
best_split = None
best_children = None
pool = Pool()
for ls, split, children in pool.map(find_best_split_parallel, zip(split_points.items(), repeat(data), repeat(label))):
if ls < best_ls:
best_ls = ls
best_split = split
best_children = children
pool.close()
|
return best_split, best_children # return a tuple(attribute, value)
def split_children(data, label, key, split):
left_index = [index for index in xrange(len(data.iloc[:,key])) if data.iloc[index,key] < split]
right_inde
|
x = [index for index in xrange(len(data.iloc[:,key])) if data.iloc[index,key] >= split]
left_data = data.iloc[left_index,:]
right_data = data.iloc[right_index,:]
left_label = [label[i] for i in left_index]
right_label =[label[i] for i in right_index]
return left_data, left_label, right_data, right_label
def least_square(label):
if not len(label):
return 0
return (np.sum(label)**2)/len(set(label))
def create_leaf(label):
global node_id
node_id += 1
leaf = {'splittng_feature': None,
'left': None,
'right':None,
'is_leaf':True,
'index':node_id}
leaf['value'] = round(np.mean(label),3)
return leaf
def find_splits_parallel(args):
var_space, label, col = args
# var_space = data.iloc[:,col].tolist()
return scipy.optimize.fminbound(error_function, min(var_space), max(var_space), args = (col, var_space, label), full_output = 1)
# return,
# if not min_error or error < min_error:
# min_error = error
# split_var = col
# min_split = split
def create_tree(data, all_pos_split, label, max_depth, ideal_ls, current_depth = 0):
remaining_features = all_pos_split
#stopping conditions
if sum([len(v)!= 0 for v in remaining_features.values()]) == 0:
# If there are no remaining features to consider, make current node a leaf node
return create_leaf(label)
# #Additional stopping condition (limit tree depth)
elif current_depth > max_depth:
return create_leaf(label)
#######
min_error = None
split_var = None
min_split = None
var_spaces = [data.iloc[:,col].tolist() for col in xrange(data.shape[1])]
cols = [col for col in xrange(data.shape[1])]
pool = Pool()
for split, error, ierr, numf in pool.map(find_splits_parallel, zip(var_spaces, repeat(label), cols)):
if not min_error or error < min_error:
min_error = error
split_var = col
min_split = split
pool.close()
splitting_feature = (split_var, min_split)
children = split_children(data, label, split_var, min_split)
left_data, left_label, right_data, right_label = children
if len(left_label) == 0 or len(right_label) == 0:
return create_leaf(label)
left_least_square = least_square(left_label)
# Create a leaf node if the split is "perfect"
if left_least_square < ideal_ls:
return create_leaf(left_label)
if least_square(right_label) < ideal_ls:
return create_leaf(right_label)
# recurse on children
left_tree = create_tree(left_data, remaining_features, left_label, max_depth, ideal_ls, current_depth +1)
right_tree = create_tree(right_data, remaining_features, right_label, max_depth, ideal_ls, current_depth +1)
return {'is_leaf' : False,
'value' : None,
'splitting_feature': splitting_feature,
'left' : left_tree,
'right' : right_tree,
'index' : None}
def error_function(split_point, split_var, data, label):
data1 = []
data2 = []
for i in xrange(len(data)):
temp_dat = data[i]
if temp_dat <= split_point:
data1.append(label[i])
else:
data2.append(label[i])
return least_square(data1) + least_square(data2)
def make_prediction(tree, x, annotate = False):
if tree['is_leaf']:
if annotate:
print "At leaf, predicting %s" % tree['value']
return tree['value']
else:
# the splitting value of x.
split_feature_value = x[tree['splitting_feature'][0]]
if annotate:
print "Split on %s = %s" % (tree['splitting_feature'], split_feature_value)
if split_feature_value < tree['splitting_feature'][1]:
return make_prediction(tree['left'], x, annotate)
else:
return make_prediction(tree['right'], x, annotate)
class RegressionTree:
def __init__(self, training_data, labels, max_depth=5, ideal_ls=100):
self.training_data = training_data
self.labels = labels
self.max_depth = max_depth
self.ideal_ls = ideal_ls
self.tree = None
def fit(self):
global node_id
node_id = 0
all_pos_split = {}
pool = Pool()
splitting_data = [self.training_data.iloc[:,col].tolist() for col in xrange(self.training_data.shape[1])]
cols = [col for col in xrange(self.training_data.shape[1])]
for dat, col in pool.map(get_splitting_points, zip(splitting_data, cols)):
all_pos_split[col] = dat
pool.close()
self.tree = create_tree(self.training_data, all_pos_split, self.labels, self.max_depth, self.ideal_ls)
def predict(self, test):
prediction = np.array([make_prediction(self.tree, x) for x in test])
return prediction
if __name__ == '__main__':
#read in data, label
data = pd.read_excel("mlr06.xls")
test = [[478, 184, 40, 74, 11, 31], [1000,10000,10000,10000,10000,1000,100000]]
label = data['X7']
del data['X7']
model = RegressionTree(data, label)
model.fit()
print model.predict(test)
|
aherlihy/Monary
|
doc/conf.py
|
Python
|
apache-2.0
| 8,410
| 0.006183
|
# -*- coding: utf-8 -*-
#
# Monary documentation build configuration file, created by
# sphinx-quickstart on Wed Jul 9 13:39:38 2014.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
import monary
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.intersphinx',
'sphinx.ext.doctest',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Monary'
copyright = u'2014, David J. C. Beach'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = monary.__version__
# The full version, including alpha/beta/rc tags.
release = monary.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
#html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'Monarydoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
('index', 'Monary.tex', u'Monary Documentation',
u'David J. C. Beach', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal
|
links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_i
|
ndices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'monary', u'Monary Documentation',
[u'David J. C. Beach'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'Monary', u'Monary Documentation',
u'David J. C. Beach', 'Monary', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If
|
dpgaspar/Flask-AppBuilder
|
flask_appbuilder/charts/views.py
|
Python
|
bsd-3-clause
| 17,665
| 0.000566
|
import logging
from flask_babel import lazy_gettext
from .jsontools import dict_to_json
from .widgets import ChartWidget, DirectChartWidget
from ..baseviews import BaseModelView, expose
from ..models.group import DirectProcessData, GroupByProcessData
from ..security.decorators import has_access
from ..urltools import get_filter_args
from ..widgets import SearchWidget
log = logging.getLogger(__name__)
class BaseChartView(BaseModelView):
"""
This is the base class for all chart views.
Use DirectByChartView or GroupByChartView, override their properties
and their base classes
(BaseView, BaseModelView, BaseChartView) to customise your charts
"""
chart_template = "appbuilder/general/charts/chart.html"
""" The chart template, override to implement your own """
chart_widget = ChartWidget
""" Chart widget override to implement your own """
search_widget = SearchWidget
""" Search widget override to implement your own """
chart_title = "Chart"
""" A title to be displayed on the chart """
title = "Title"
group_by_label = lazy_gettext("Group by")
""" The label that is displayed for the chart selection """
default_view = "chart"
chart_type = "PieChart"
""" The chart type PieChart, ColumnChart, LineChart """
chart_3d = "true"
""" Will display in 3D? """
width = 400
""" The width """
height = "400px"
group_bys = {}
""" New for 0.6.4, on test, don't use yet """
def __init__(self, **kwargs):
self._init_titles()
super(BaseChartView, self).__init__(**kwargs)
def _init_titles(self):
self.title = self.chart_title
def _get_chart_widget(self, filters=None, widgets=None, **args):
raise NotImplementedError
def _get_view_widget(self, **kwargs):
"""
:return:
Returns a widget
"""
return self._get_chart_widget(**kwargs).get("chart")
class GroupByChartView(BaseChartView):
definitions = []
"""
These charts can display multiple series,
based on columns or methods defined on models.
You can display multiple charts on the same view.
This data can be grouped and aggregated has you like.
:label: (optional) String label to display on chart selection.
:group: String with the column name or method from model.
:formatter: (optional) function that formats the output of 'group' key
:series: A list of tuples with the aggregation function and the column name
to apply the aggregation
::
[{
'label': 'String',
'group': '<COLNAME>'|'<FUNCNAME>'
'formatter: <FUNC>
'series': [(<AGGR FUNC>, <COLNAME>|'<FUNCNAME>'),...]
}
]
example::
class CountryGroupByChartView(GroupByChartView):
datamodel = SQLAInterface(CountryStats)
chart_title = 'Statistics'
definitions = [
{
'label': 'Country Stat',
'group': 'country',
'series': [(aggregate_avg, 'unemployed_perc'),
(aggregate_avg, 'population'),
(aggregate_avg, 'college_perc')
]
}
]
"""
chart_type = "ColumnChart"
chart_template = "appbuilder/general/charts/jsonchart.html"
chart_widget = DirectChartWidget
ProcessClass = GroupByProcessData
def __init__(self, **kwargs):
super(GroupByChartView, self).__init__(**kwargs)
for definition in self.definitions:
col = definition.get("group")
# Setup labels
try:
self.label_columns[col] = (
definition.get("label") or self.label_columns[col]
)
except Exception:
self.label_columns[col] = self._prettify_column(col)
if not definition.get("label"):
definition["label"] = self.label_columns[col]
# Setup Series
for serie in definition["series"]:
if isinstance(serie, tuple):
if hasattr(serie[0], "_label"):
key = serie[0].__name__ + serie[1]
self.label_columns[key] = (
serie[0]._label + " " + self._prettify_column(serie[1])
)
else:
self.label_columns[serie] = self._prettify_column(serie)
def get_group_by_class(self, definition):
"""
intantiates the processing class (Direct or Grouped) and returns it.
"""
group_by = definition["group"]
series = definition["series"]
if "formatter" in definition:
formatter = {group_by: definition["formatter"]}
else:
formatter = {}
return self.ProcessClass([group_by], series, formatter)
def _get_chart_widget(
self,
filters=None,
order_column="",
order_direction="",
widgets=None,
direct=None,
height=None,
|
definition="",
**args
):
|
height = height or self.height
widgets = widgets or dict()
joined_filters = filters.get_joined_filters(self._base_filters)
# check if order_column may be database ordered
if not self.datamodel.get_order_columns_list([order_column]):
order_column = ""
order_direction = ""
count, lst = self.datamodel.query(
filters=joined_filters,
order_column=order_column,
order_direction=order_direction,
)
if not definition:
definition = self.definitions[0]
group = self.get_group_by_class(definition)
value_columns = group.to_json(
group.apply(lst, sort=order_column == ""), self.label_columns
)
widgets["chart"] = self.chart_widget(
route_base=self.route_base,
chart_title=self.chart_title,
chart_type=self.chart_type,
chart_3d=self.chart_3d,
height=height,
value_columns=value_columns,
modelview_name=self.__class__.__name__,
**args
)
return widgets
@expose("/chart/<group_by>")
@expose("/chart/")
@has_access
def chart(self, group_by=0):
group_by = int(group_by)
form = self.search_form.refresh()
get_filter_args(self._filters)
widgets = self._get_chart_widget(
filters=self._filters,
definition=self.definitions[group_by],
order_column=self.definitions[group_by]["group"],
order_direction="asc",
)
widgets = self._get_search_widget(form=form, widgets=widgets)
self.update_redirect()
return self.render_template(
self.chart_template,
route_base=self.route_base,
title=self.chart_title,
label_columns=self.label_columns,
definitions=self.definitions,
group_by_label=self.group_by_label,
height=self.height,
widgets=widgets,
appbuilder=self.appbuilder,
)
class DirectByChartView(GroupByChartView):
"""
Use this class to display charts with multiple series,
based on columns or methods defined on models.
You can display multiple charts on the same view.
Default routing point is '/chart'
Setup definitions property to configure the chart
:label: (optional) String label to display on chart selection.
:group: String with the column name or method from model.
:formatter: (optional) function that formats the output of 'group' key
:series: A list of tuples with the aggregation function and the column name
to apply the aggregation
The **definitions** property respects the following grammar::
definitions = [
|
mjfarmer/scada_py
|
pymodbus/examples/common/asynchronous-client.py
|
Python
|
gpl-3.0
| 5,916
| 0.011663
|
#!/usr/bin/env python
'''
Pymodbus Asynchronous Client Examples
--------------------------------------------------------------------------
The following is an example of how to use the asynchronous modbus
client implementation from pymodbus.
'''
#---------------------------------------------------------------------------#
# import needed libraries
#---------------------------------------------------------------------------#
from twisted.internet import reactor, protocol
from pymodbus.constants import Defaults
#---------------------------------------------------------------------------#
# choose the requested modbus protocol
#---------------------------------------------------------------------------#
from pymodbus.client.async import ModbusClientProtocol
#from pymodbus.client.async import ModbusUdpClientProtocol
#---------------------------------------------------------------------------#
# configure the client logging
#---------------------------------------------------------------------------#
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.DEBUG)
#---------------------------------------------------------------------------#
# helper method to test deferred callbacks
#---------------------------------------------------------------------------#
def dassert(deferred, callback):
def _assertor(value): assert(value)
deferred.addCallback(lambda r: _assertor(callback(r)))
deferred.addErrback(lambda _: _assertor(False))
#---------------------------------------------------------------------------#
# specify slave to query
#---------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be do
|
ne by specifying the `unit` parameter
# which defaults to `0x00`
#---------------------------------------------------------------------------#
def exampleRequests(client):
rr = client.read_coils(1, 1, unit=0x02)
#---------------------------------------------------------------------------#
# example requests
#--------------------
|
-------------------------------------------------------#
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that unlike the
# synchronous version of the client, the asynchronous version returns
# deferreds which can be thought of as a handle to the callback to send
# the result of the operation. We are handling the result using the
# deferred assert helper(dassert).
#---------------------------------------------------------------------------#
def beginAsynchronousTest(client):
rq = client.write_coil(1, True)
rr = client.read_coils(1,1)
dassert(rq, lambda r: r.function_code < 0x80) # test that we are not an error
dassert(rr, lambda r: r.bits[0] == True) # test the expected value
rq = client.write_coils(1, [True]*8)
rr = client.read_coils(1,8)
dassert(rq, lambda r: r.function_code < 0x80) # test that we are not an error
dassert(rr, lambda r: r.bits == [True]*8) # test the expected value
rq = client.write_coils(1, [False]*8)
rr = client.read_discrete_inputs(1,8)
dassert(rq, lambda r: r.function_code < 0x80) # test that we are not an error
dassert(rr, lambda r: r.bits == [True]*8) # test the expected value
rq = client.write_register(1, 10)
rr = client.read_holding_registers(1,1)
dassert(rq, lambda r: r.function_code < 0x80) # test that we are not an error
dassert(rr, lambda r: r.registers[0] == 10) # test the expected value
rq = client.write_registers(1, [10]*8)
rr = client.read_input_registers(1,8)
dassert(rq, lambda r: r.function_code < 0x80) # test that we are not an error
dassert(rr, lambda r: r.registers == [17]*8) # test the expected value
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
rq = client.readwrite_registers(**arguments)
rr = client.read_input_registers(1,8)
dassert(rq, lambda r: r.registers == [20]*8) # test the expected value
dassert(rr, lambda r: r.registers == [17]*8) # test the expected value
#-----------------------------------------------------------------------#
# close the client at some time later
#-----------------------------------------------------------------------#
reactor.callLater(1, client.transport.loseConnection)
reactor.callLater(2, reactor.stop)
#---------------------------------------------------------------------------#
# extra requests
#---------------------------------------------------------------------------#
# If you are performing a request that is not available in the client
# mixin, you have to perform the request like this instead::
#
# from pymodbus.diag_message import ClearCountersRequest
# from pymodbus.diag_message import ClearCountersResponse
#
# request = ClearCountersRequest()
# response = client.execute(request)
# if isinstance(response, ClearCountersResponse):
# ... do something with the response
#
#---------------------------------------------------------------------------#
#---------------------------------------------------------------------------#
# choose the client you want
#---------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#---------------------------------------------------------------------------#
defer = protocol.ClientCreator(reactor, ModbusClientProtocol
).connectTCP("localhost", Defaults.Port)
defer.addCallback(beginAsynchronousTest)
reactor.run()
|
tiangolo/fastapi
|
tests/test_tutorial/test_query_params_str_validations/test_tutorial011_py310.py
|
Python
|
mit
| 3,293
| 0.000607
|
import pytest
from fastapi.testclient import TestClient
from ...utils import needs_py310
openapi_schema = {
"openapi": "3.0.2",
"info": {"title": "FastAPI", "version": "0.1.0"},
"paths": {
"/items/": {
"get": {
"responses": {
"200": {
"description": "Successful Response",
"content": {"application/json": {"schema": {}}},
},
"422": {
"description": "Validation Error",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/HTTPValidationError"
}
}
},
},
},
"summary": "Read Items",
"operationId": "read_items_items__get",
"parameters": [
{
"required": False,
"schema": {
|
"title": "Q",
"type": "array",
"items": {"type": "string"},
},
|
"name": "q",
"in": "query",
}
],
}
}
},
"components": {
"schemas": {
"ValidationError": {
"title": "ValidationError",
"required": ["loc", "msg", "type"],
"type": "object",
"properties": {
"loc": {
"title": "Location",
"type": "array",
"items": {"type": "string"},
},
"msg": {"title": "Message", "type": "string"},
"type": {"title": "Error Type", "type": "string"},
},
},
"HTTPValidationError": {
"title": "HTTPValidationError",
"type": "object",
"properties": {
"detail": {
"title": "Detail",
"type": "array",
"items": {"$ref": "#/components/schemas/ValidationError"},
}
},
},
}
},
}
@pytest.fixture(name="client")
def get_client():
from docs_src.query_params_str_validations.tutorial011_py310 import app
client = TestClient(app)
return client
@needs_py310
def test_openapi_schema(client: TestClient):
response = client.get("/openapi.json")
assert response.status_code == 200, response.text
assert response.json() == openapi_schema
@needs_py310
def test_multi_query_values(client: TestClient):
url = "/items/?q=foo&q=bar"
response = client.get(url)
assert response.status_code == 200, response.text
assert response.json() == {"q": ["foo", "bar"]}
@needs_py310
def test_query_no_values(client: TestClient):
url = "/items/"
response = client.get(url)
assert response.status_code == 200, response.text
assert response.json() == {"q": None}
|
QuantumQuadrate/CsPyController
|
python/vaunix.py
|
Python
|
lgpl-3.0
| 9,955
| 0.012858
|
from __future__ import division
"""
instek_pst.py
part of the CsPyController package for AQuA experiment control by Martin Lichtman
Handles sending commands to Instek PST power supplies over RS232.
created = 2015.07.09
modified >= 2015.07.09
"""
__author__ = 'Martin Lichtman'
import logging
logger = logging.getLogger(__name__)
from atom.api import Bool, Str, Member, Int
from instrument_property import Prop, IntProp, ListProp, FloatProp
from cs_instruments import Instrument
from cs_errors import PauseError
from ctypes import *
class Vaunix(Prop):
isInitialized = Bool(False)
ID = Int()
va = Member()
model = Str()
serial = Int()
frequency = Member()
power = Member()
pulsewidth = Member()
pulserep = Member()
pulseenable = Bool()
startfreq = Member()
endfreq = Member()
sweeptime = Member()
sweepmode = Bool()
sweeptype = Bool()
sweepenable = Bool()
sweepdir = Bool()
internalref = Bool()
useexternalmod = Bool()
rfonoff = Bool()
maxPower = Int()
minPower = Int()
minFreq = Int()
maxFreq = Int()
def __init__(self, name, experiment, description=''):
super(Vaunix, self).__init__(name, experiment, description)
self.frequency = FloatProp('Frequency', experiment, 'Frequency (MHz)', '0')
self.power = FloatProp('Power', experiment, 'Power (dBm)', '0')
self.pulsewidth = FloatProp('PulseWidth', experiment, 'Pulse Width (us)', '0')
self.pulserep = FloatProp('PulseRep', experiment, 'Pulse Rep Time (us)', '0')
self.startfreq = FloatProp('StartFreq', experiment, 'Start Frequency (MHz)', '0')
self.endfreq = FloatProp('EndFreq', experiment, 'End Frequency (MHz)', '0')
self.sweeptime = IntProp('SweepTime', experiment, 'Sweep Time (ms)', '0')
self.properties += ['ID', 'model', 'serial', 'frequency','power','pulsewidth','pulserep','pulseenable','startfreq','endfreq','sweeptime',
'sweepmode', 'sweeptype', 'sweepdir', 'sweepenable', 'internalref', 'useexternalmod', 'rfonoff', 'maxPower']
def initialize(self,va):
self.va = va
errcode = self.va.fnLMS_InitDevice(self.ID)
if (errcode !=0):
errcodereset = self.va.fnLMS_CloseDevice(self.ID)
if (errcodereset != 0): #if device fails to initialize, it may be because it was not closed previously. Try closing and reinitializing it.
logger.error("Failed to initialize Vaunix device {}. Error code {}.".format(self.ID,errcode))
raise PauseError
errcode = self.va.fnLMS_InitDevice(self.ID)
if (errcode != 0):
logger.error("Failed to initialize Vaunix device {}. Error code {}.".format(self.ID,errcode))
raise PauseError
self.maxPower = int(self.va.fnLMS_GetMaxPwr(self.ID)/4)
self.minPower = int(self.va.fnLMS_GetMinPwr(self.ID)/4)
self.minFreq = int(self.va.fnLMS_GetMinFreq(self.ID))
self.maxFreq = int(self.va.fnLMS_GetMaxFreq(self.ID))
return
def freq_unit(self,val):
return int(val*100000)
def power_unit(self,value):
return int((self.maxPower - value)*4)
def power_sanity_check(self,value):
if (value < self.minPower or value > self.maxPower):
logger.error("Vaunix device {} power ({} dBm) outside min/max range: {} dBm, {} dBm.".format(self.ID,value,self.minPower,self.maxPower))
raise PauseError
return
def freq_sanity_check(self,value):
if (value < self.minFreq or value > self.maxFreq):
logger.error("Vaunix device {} frequency ({} x10 Hz) outside min/max range: {} x10 Hz, {} x10 Hz.".format(self.ID,value,self.minFreq,self.maxFreq))
raise PauseError
return
def update(self):
if (self.rfonoff):
self.freq_sanity_check(self.freq_unit(self.frequency.value))
self.va.fnLMS_SetFrequency(self.ID, self.freq_unit(self.frequency.value))
self.power_sanity_check(self.power.value)
self.va.fnLMS_SetPowerLevel(self.ID, self.power_unit(self.power.value))
if (self.sweepenable):
self.freq_sanity_check(self.freq_unit(self.startfreq.value))
self.va.fnLMS_SetStartFrequency(self.ID, self.freq_unit(self.startfreq.value))
self.freq_sanity_check(self.freq_unit(self.endfreq.value))
self.va.fnLMS_SetEndFrequency(self.ID, self.freq_unit(self.endfreq.value))
self.va.fnLMS_SetSweepTime(self.ID, self.sweeptime.value)
self.va.fnLMS_SetSweepDirection(self.ID, self.sweepdir)
self.va.fnLMS_SetSweepMode(self.ID, self.sweepmode) #True: Repeat Sweep, False: Sweep Once
self.va.fnLMS_SetSweepType(self.ID, self.sweeptype) #True: Bidirectional Sweep, False: Unidirectional Sweep
self.va.fnLMS_StartSweep(self.ID, self.sweepenable)
self.va.fnLMS_SetFastPulsedOutput(self.ID, c_float(self.pulsewidth.value*1e-6), c_float(self.pulserep.value*1e-6), self.pulseenable)
self.va.fnLMS_SetUseExternalPulseMod(self.ID, self.useexternalmod)
self.va.fnLMS_SetUseInternalRef(self.ID, self.internalref) #True: internal ref, False: external ref
self.va.fnLMS_SaveSettings(self.ID)
self.va.fnLMS_SetRFOn(self.ID, self.rfonoff)
self.getparams()
return
def getparams(self):
logger.info("Parameters for Vaunix # {}".format(self.ID))
logger.info("Frequency: {} MHz".format(
self.va.fnLMS_GetFrequency(self.ID)/100000))
logger.info("Power Level: {} dBm".format(
self.va.fnLMS_GetPowerLevel(self.ID)/4))
class Vaunixs(Instrument):
version = '2015.11.19'
motors = Member()
isInitialized = Bool(False)
va = Member()
testMode = Bool(False) #Test mode: Set to False for actual use.
def __init__(self, name, experiment, description=''):
super(Vaunixs, self).__init__(name, experiment, description)
self.motors = ListProp('motors', experiment, 'A list of individual Vaunix signal generators', listElementType=Vaunix,
listElementName='Vaunix')
self.properties += ['version', 'motors']
num = self.initialize()
self.motors.length = num
self.motors.refreshGUI()
#Initialize: loads and initializes DLL
def initialize(self):
num = 0
if self.enable:
CDLL_file = "./vaunix/VNX_fmsynth.dll"
|
self.va = CDLL(CDLL_file)
if (self.testMode):
logger.warning("Warning: Vaunix in test mode. Set testMode=False in vaunix.py to turn off test mode.")
self.va.fnLMS_SetTestMode(self.testMode) #Test mode... this needs to be set False for actual run. Do not remove this command (default setting is True).
self.isInitialized = True
num = self.detect_generators()
return num
def preExperiment(s
|
elf, hdf5):
if self.enable:
if (not self.isInitialized):
self.initialize()
for i in self.motors:
#initialize serial connection to each power supply
i.initialize(self.va)
self.isInitialized = True
def preIteration(self, iterationresults, hdf5):
"""
Every iteration, send the motors updated positions.
"""
if self.enable:
msg = ''
try:
for i in self.motors:
i.update()
except Exception as e:
logger.error('Proble
|
kaarl/pyload
|
module/plugins/hoster/XDCC.py
|
Python
|
gpl-3.0
| 7,856
| 0.006237
|
# -*- coding: utf-8 -*-
import os
import re
import select
import socket
import struct
import time
from module.plugins.internal.Hoster import Hoster
from module.plugins.internal.misc import exists, fsjoin
class XDCC(Hoster):
__name__ = "XDCC"
__type__ = "hoster"
__version__ = "0.42"
__status__ = "testing"
__pattern__ = r'xdcc://(?P<SERVER>.*?)/#?(?P<CHAN>.*?)/(?P<BOT>.*?)/#?(?P<PACK>\d+)/?'
__config__ = [("nick", "str", "Nickname", "pyload" ),
("ident", "str", "Ident", "pyloadident" ),
("realname", "str", "Realname", "pyloadreal" ),
("ctcp_version", "str","CTCP version string", "pyLoad! IRC Interface")]
__description__ = """Download from IRC XDCC bot"""
__license__ = "GPLv3"
__authors__ = [("jeix", "[email protected]" ),
("GammaC0de", "nitzo2001[AT]yahoo[DOT]com")]
def setup(self):
self.timeout = 30
self.multiDL = False
def process(self, pyfile):
#: Change request type
self.req = self.pyload.requestFactory.getRequest(self.classname, type="XDCC")
for _i in xrange(0, 3):
try:
nmn = self.do_download(pyfile.url)
self.log_info("Download of %s finished." %
|
nmn)
|
return
except socket.error, e:
if hasattr(e, "errno") and e.errno is not None:
err_no = e.errno
if err_no in (10054, 10061):
self.log_warning("Server blocked our ip, retry in 5 min")
self.wait(300)
continue
else:
self.log_error(_("Failed due to socket errors. Code: %s") % err_no)
self.fail(_("Failed due to socket errors. Code: %s") % err_no)
else:
err_msg = e.args[0]
self.log_error(_("Failed due to socket errors: '%s'") % err_msg)
self.fail(_("Failed due to socket errors: '%s'") % err_msg)
self.log_error(_("Server blocked our ip, retry again later manually"))
self.fail(_("Server blocked our ip, retry again later manually"))
def do_download(self, url):
self.pyfile.setStatus("waiting")
server, chan, bot, pack = re.match(self.__pattern__, url).groups()
nick = self.config.get('nick')
ident = self.config.get('ident')
realname = self.config.get('realname')
ctcp_version = self.config.get('ctcp_version')
temp = server.split(':')
ln = len(temp)
if ln == 2:
host, port = temp
elif ln == 1:
host, port = temp[0], 6667
else:
self.fail(_("Invalid hostname for IRC Server: %s") % server)
#######################
#: CONNECT TO IRC AND IDLE FOR REAL LINK
dl_time = time.time()
sock = socket.socket()
self.log_info(_("Connecting to: %s:%s") % (host, port))
sock.connect((host, int(port)))
if nick == "pyload":
nick = "pyload-%d" % (time.time() % 1000) #: last 3 digits
sock.send("NICK %s\r\n" % nick)
sock.send("USER %s %s bla :%s\r\n" % (ident, host, realname))
self.log_info(_("Connect success."))
self.wait(5) # Wait for logon to complete
sock.send("JOIN #%s\r\n" % chan)
sock.send("PRIVMSG %s :xdcc send #%s\r\n" % (bot, pack))
#: IRC recv loop
readbuffer = ""
retry = None
m = None
while m is None:
if retry:
if time.time() > retry:
retry = None
dl_time = time.time()
sock.send("PRIVMSG %s :xdcc send #%s\r\n" % (bot, pack))
else:
if (dl_time + self.timeout) < time.time(): #@TODO: add in config
sock.send("QUIT :byebye\r\n")
sock.close()
self.log_error(_("XDCC Bot did not answer"))
self.fail(_("XDCC Bot did not answer"))
fdset = select.select([sock], [], [], 0)
if sock not in fdset[0]:
continue
readbuffer += sock.recv(1024)
lines = readbuffer.split("\n")
readbuffer = lines.pop()
for line in lines:
# if self.pyload.debug:
# self.log_debug("*> " + decode(line))
line = line.rstrip()
first = line.split()
if first[0] == "PING":
sock.send("PONG %s\r\n" % first[1])
if first[0] == "ERROR":
self.fail(_("IRC-Error: %s") % line)
msg = line.split(None, 3)
if len(msg) != 4:
continue
msg = {'origin': msg[0][1:],
'action': msg[1],
'target': msg[2],
'text' : msg[3][1:]}
if msg['target'][0:len(nick)] == nick and msg['action'] == "PRIVMSG":
if msg['text'] == "\x01VERSION\x01":
self.log_debug(_("Sending CTCP VERSION"))
sock.send("NOTICE %s :%s\r\n" % (msg['origin'], ctcp_version))
elif msg['text'] == "\x01TIME\x01":
self.log_debug(_("Sending CTCP TIME"))
sock.send("NOTICE %s :%d\r\n" % (msg['origin'], time.time()))
elif msg['text'] == "\x01LAG\x01":
pass #: don't know how to answer
if msg['origin'][0:len(bot)] != bot\
or msg['target'][0:len(nick)] != nick\
or msg['action'] not in ("PRIVMSG", "NOTICE"):
continue
self.log_debug(_("PrivMsg: <%s> - %s" % (msg['origin'], msg['text'])))
if "You already requested that pack" in msg['text']:
retry = time.time() + 300
elif "you must be on a known channel to request a pack" in msg['text']:
self.log_error(_("Invalid channel"))
self.fail(_("Invalid channel"))
m = re.match('\x01DCC SEND (?P<NAME>.*?) (?P<IP>\d+) (?P<PORT>\d+)(?: (?P<SIZE>\d+))?\x01', msg['text'])
#: Get connection data
ip = socket.inet_ntoa(struct.pack('!I', int(m.group('IP'))))
port = int(m.group('PORT'))
file_name = m.group('NAME')
if m.group('SIZE'):
self.req.filesize = long(m.group('SIZE'))
self.pyfile.name = file_name
dl_folder = fsjoin(self.pyload.config.get('general', 'download_folder'),
self.pyfile.package().folder if self.pyload.config.get("general",
"folder_per_package") else "")
dl_file = fsjoin(dl_folder, file_name)
if not exists(dl_folder):
os.makedirs(dl_folder)
self.set_permissions(dl_folder)
self.log_info(_("Downloading %s from %s:%d") % (file_name, ip, port))
self.pyfile.setStatus("downloading")
newname = self.req.download(ip, port, dl_file, sock, self.pyfile.setProgress)
if newname and newname != dl_file:
self.log_info(_("%(name)s saved as %(newname)s") % {'name': self.pyfile.name, 'newname': newname})
dl_file = newname
#: kill IRC socket
#: sock.send("QUIT :byebye\r\n")
sock.close()
self.last_download = dl_file
return self.last_download
|
chintak/image-captioning
|
scripts/tfrecord_writer.py
|
Python
|
mit
| 5,331
| 0.002626
|
import os
import argparse
import tensorflow as tf
import numpy as np
import sys
sys.path.append('../')
from reader import flickr8k_raw_data
def make_example(image_feature, caption_feature, id):
# The object we return
ex = tf.train.SequenceExample()
# A non-sequential feature of our example
sequence_length = len(caption_feature)
for f in image_feature:
ex.context.feature["image_feature"].float_list.value.append(float(f))
ex.context.feature["id"].bytes_list.value.append(id)
fl_tokens = ex.feature_lists.feature_list["caption_feature"]
for token in caption_feature:
fl_tokens.feature.add().int64_list.value.append(token)
return ex
def arguments():
parser = argparse.ArgumentParser()
parser.add_argument('cnn_feats_path', help='a numpy.mmap expected')
parser.add_argument(
'caption_tokens_dir',
help='Directory containing train, test and dev captions.')
args = parser.parse_args()
return args
def _strip_name(paths):
return [(os.path.basename(p), i) for i, p in enumerate(paths)]
def main():
args = arguments()
# read the mmap file containing CNN features
feats_fname = os.path.splitext(os.path.basename(args.cnn_feats_path))[0]
img_name_list_path = os.path.join(
os.path.dirname(args.cnn_feats_path),
'{}_list.txt'.format(
'_'.join(feats_fname.split('_')[:-3])))
feats_shape = tuple([int(i) for i in feats_fname.split('_')[-1].split('X')])
feats_mmap = np.memmap(args.cnn_feats_path, mode='r', # read-only
shape=feats_shape, dtype=np.float32)
img_to_idx = {}
with open(img_name_list_path, 'r') as fp:
img_to_idx = dict(_strip_name(fp.read().split('\n')))
# load all the captions
train_caps, test_caps, dev_caps, vocab = flickr8k_raw_data(
args.caption_tokens_dir)
rand_idx = np.arange(0, len(train_caps['names']))
rng = np.random.RandomState(seed=1234)
rng.shuffle(rand_idx)
# dump the captions generated for debugging purpose
with open(os.path.join(args.capti
|
on_tokens_dir, 'dump.txt'), 'w') as fp:
from pprint import pformat
fp.write("\n###### vocab######\n")
fp.write(pformat(vocab))
fp.write("\n###### tra
|
in ######\n")
rand_train_caps = {
'names': [train_caps['names'][i] for i in rand_idx],
'word_to_ids': [train_caps['word_to_ids'][i] for i in rand_idx],
}
fp.write(pformat([(n, w) for n, w in zip(
rand_train_caps['names'], rand_train_caps['word_to_ids'])]))
fp.write("\n###### test ######\n")
fp.write(pformat([(n, w) for n, w in zip(
test_caps['names'], test_caps['word_to_ids'])]))
fp.write("\n###### dev ######\n")
fp.write(pformat([(n, w) for n, w in zip(
dev_caps['names'], dev_caps['word_to_ids'])]))
# process train imgs and write to a record file
train_tfrecord_name = os.path.join(
args.caption_tokens_dir, '{}.train.tfrecord'.format(
'_'.join(feats_fname.split('_')[:-3])))
train_writer = tf.python_io.TFRecordWriter(train_tfrecord_name)
# for i, (img_name, cap_ids) in enumerate(
# zip(train_caps['names'], train_caps['word_to_ids'])):
for i, (idx) in enumerate(rand_idx):
img_name = train_caps['names'][idx].split('#')[0]
cap_ids = train_caps['word_to_ids'][idx]
img_feat = feats_mmap[img_to_idx[img_name], :]
train_writer.write(
make_example(img_feat, cap_ids, img_name).SerializeToString())
if i % 100 == 0:
print "train records written {}/{}".format(
i, len(train_caps['names']))
train_writer.close()
# process test imgs and write to a record file
test_tfrecord_name = os.path.join(
args.caption_tokens_dir, '{}.test.tfrecord'.format(
'_'.join(feats_fname.split('_')[:-3])))
test_writer = tf.python_io.TFRecordWriter(test_tfrecord_name)
for i, (img_name, cap_ids) in enumerate(
zip(test_caps['names'], test_caps['word_to_ids'])):
img_name = img_name.split('#')[0]
img_feat = feats_mmap[img_to_idx[img_name], :]
test_writer.write(
make_example(img_feat, cap_ids, img_name).SerializeToString())
if i % 100 == 0:
print "test records written {}/{}".format(
i, len(test_caps['names']))
test_writer.close()
# process dev imgs and write to a record file
dev_tfrecord_name = os.path.join(
args.caption_tokens_dir, '{}.dev.tfrecord'.format(
'_'.join(feats_fname.split('_')[:-3])))
dev_writer = tf.python_io.TFRecordWriter(dev_tfrecord_name)
for i, (img_name, cap_ids) in enumerate(
zip(dev_caps['names'], dev_caps['word_to_ids'])):
img_name = img_name.split('#')[0]
img_feat = feats_mmap[img_to_idx[img_name], :]
dev_writer.write(
make_example(img_feat, cap_ids, img_name).SerializeToString())
if i % 100 == 0:
print "dev records written {}/{}".format(
i, len(dev_caps['names']))
dev_writer.close()
print "Wrote to %s" % train_tfrecord_name
print "Wrote to %s" % dev_tfrecord_name
print "Wrote to %s" % test_tfrecord_name
if __name__ == '__main__':
main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.