repo_name
stringlengths 5
92
| path
stringlengths 4
232
| copies
stringclasses 22
values | size
stringlengths 4
7
| content
stringlengths 626
1.05M
| license
stringclasses 15
values | hash
int64 -9,223,277,421,539,062,000
9,223,102,107B
| line_mean
float64 5.21
99.9
| line_max
int64 12
999
| alpha_frac
float64 0.25
0.96
| autogenerated
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|
libyal/libyal | yaldevtools/definitions.py | 1 | 1409 | # -*- coding: utf-8 -*-
"""The definitions."""
from __future__ import unicode_literals
DATA_TYPE_BOOLEAN = 'boolean'
DATA_TYPE_BINARY_DATA = 'binary_data'
DATA_TYPE_DOUBLE = 'double'
DATA_TYPE_FAT_DATE_TIME = 'fat_date_time'
DATA_TYPE_FILETIME = 'filetime'
DATA_TYPE_FLOAT = 'float'
DATA_TYPE_FLOATINGTIME = 'floatingtime'
DATA_TYPE_HFS_TIME = 'hfs_time'
DATA_TYPE_GUID = 'guid'
DATA_TYPE_INT = 'int'
DATA_TYPE_INT32 = 'int32'
DATA_TYPE_NARROW_STRING = 'narrow_string'
DATA_TYPE_NONE = 'none'
DATA_TYPE_OBJECT = 'object'
DATA_TYPE_OFF64 = 'off64'
DATA_TYPE_POSIX_TIME = 'posix_time'
DATA_TYPE_SIZE32 = 'size32'
DATA_TYPE_SIZE64 = 'size64'
DATA_TYPE_STRING = 'string'
DATA_TYPE_UINT8 = 'uint8'
DATA_TYPE_UINT16 = 'uint16'
DATA_TYPE_UINT32 = 'uint32'
DATA_TYPE_UINT64 = 'uint64'
DATA_TYPE_UUID = 'uuid'
FUNCTION_TYPE_CLOSE = 'close'
FUNCTION_TYPE_COPY = 'copy'
FUNCTION_TYPE_COPY_FROM = 'copy_from'
FUNCTION_TYPE_COPY_TO = 'copy_to'
FUNCTION_TYPE_FREE = 'free'
FUNCTION_TYPE_GET = 'get'
FUNCTION_TYPE_GET_BY_INDEX = 'get_by_index'
FUNCTION_TYPE_GET_BY_IDENTIFIER = 'get_by_identifier'
FUNCTION_TYPE_GET_BY_NAME = 'get_by_name'
FUNCTION_TYPE_GET_BY_PATH = 'get_by_path'
FUNCTION_TYPE_INITIALIZE = 'initialize'
FUNCTION_TYPE_IS = 'is'
FUNCTION_TYPE_OPEN = 'open'
FUNCTION_TYPE_READ = 'read'
FUNCTION_TYPE_SEEK = 'seek'
FUNCTION_TYPE_SET = 'set'
FUNCTION_TYPE_UTILITY = 'utility'
FUNCTION_TYPE_WRITE = 'write'
| apache-2.0 | 2,838,674,518,745,749,000 | 27.755102 | 53 | 0.713272 | false |
Ircam-Web/mezzanine-organization | organization/pages/migrations/0014_auto_20161028_1516.py | 1 | 1131 | # -*- coding: utf-8 -*-
# Generated by Django 1.9.10 on 2016-10-28 13:16
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('pages', '0005_auto_20160923_1219'),
('organization-pages', '0013_auto_20161026_1025'),
]
operations = [
migrations.CreateModel(
name='PageRelatedTitle',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('title', models.CharField(blank=True, max_length=1024, null=True, verbose_name='title')),
('page', models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='related_title', to='pages.Page', verbose_name='page')),
],
options={
'verbose_name': 'related title',
},
),
migrations.AlterOrderWithRespectTo(
name='pagerelatedtitle',
order_with_respect_to='page',
),
]
| agpl-3.0 | 5,761,957,583,470,936,000 | 34.34375 | 184 | 0.594164 | false |
fmfn/UnbalancedDataset | imblearn/under_sampling/_prototype_selection/tests/test_instance_hardness_threshold.py | 2 | 3098 | """Test the module ."""
# Authors: Guillaume Lemaitre <[email protected]>
# Christos Aridas
# License: MIT
import pytest
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB as NB
from sklearn.utils._testing import assert_array_equal
from imblearn.under_sampling import InstanceHardnessThreshold
RND_SEED = 0
X = np.array(
[
[-0.3879569, 0.6894251],
[-0.09322739, 1.28177189],
[-0.77740357, 0.74097941],
[0.91542919, -0.65453327],
[-0.03852113, 0.40910479],
[-0.43877303, 1.07366684],
[-0.85795321, 0.82980738],
[-0.18430329, 0.52328473],
[-0.30126957, -0.66268378],
[-0.65571327, 0.42412021],
[-0.28305528, 0.30284991],
[0.20246714, -0.34727125],
[1.06446472, -1.09279772],
[0.30543283, -0.02589502],
[-0.00717161, 0.00318087],
]
)
Y = np.array([0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0])
ESTIMATOR = GradientBoostingClassifier(random_state=RND_SEED)
def test_iht_init():
sampling_strategy = "auto"
iht = InstanceHardnessThreshold(
estimator=ESTIMATOR, sampling_strategy=sampling_strategy, random_state=RND_SEED,
)
assert iht.sampling_strategy == sampling_strategy
assert iht.random_state == RND_SEED
def test_iht_fit_resample():
iht = InstanceHardnessThreshold(estimator=ESTIMATOR, random_state=RND_SEED)
X_resampled, y_resampled = iht.fit_resample(X, Y)
assert X_resampled.shape == (12, 2)
assert y_resampled.shape == (12,)
def test_iht_fit_resample_half():
sampling_strategy = {0: 3, 1: 3}
iht = InstanceHardnessThreshold(
estimator=NB(), sampling_strategy=sampling_strategy, random_state=RND_SEED,
)
X_resampled, y_resampled = iht.fit_resample(X, Y)
assert X_resampled.shape == (6, 2)
assert y_resampled.shape == (6,)
def test_iht_fit_resample_class_obj():
est = GradientBoostingClassifier(random_state=RND_SEED)
iht = InstanceHardnessThreshold(estimator=est, random_state=RND_SEED)
X_resampled, y_resampled = iht.fit_resample(X, Y)
assert X_resampled.shape == (12, 2)
assert y_resampled.shape == (12,)
def test_iht_fit_resample_wrong_class_obj():
from sklearn.cluster import KMeans
est = KMeans()
iht = InstanceHardnessThreshold(estimator=est, random_state=RND_SEED)
with pytest.raises(ValueError, match="Invalid parameter `estimator`"):
iht.fit_resample(X, Y)
def test_iht_reproducibility():
from sklearn.datasets import load_digits
X_digits, y_digits = load_digits(return_X_y=True)
idx_sampled = []
for seed in range(5):
est = RandomForestClassifier(n_estimators=10, random_state=seed)
iht = InstanceHardnessThreshold(estimator=est, random_state=RND_SEED)
iht.fit_resample(X_digits, y_digits)
idx_sampled.append(iht.sample_indices_.copy())
for idx_1, idx_2 in zip(idx_sampled, idx_sampled[1:]):
assert_array_equal(idx_1, idx_2)
| mit | 3,621,761,623,600,403,500 | 31.270833 | 88 | 0.666559 | false |
dewuem/python-bioinf | sliding_window.py | 1 | 2485 | #!/usr/bin/env python2
# Daniel Elsner
# Creates a sliding window of sequence pieces to blast against
# takes two arguments, input file and window size. Only the first record
# in a fasta will be used, the rest ignored.
from Bio import SeqIO # read sequence files
import sys
# read your sequence file
try:
with open(sys.argv[1], "rU") as fileA:
fcontent = list(SeqIO.parse(fileA, "fasta"))
fileA.close()
except IOError as exc: # it will complain if you try to open a directory instead of a file
if exc.errno != errno.EISDIR:
raise
# the function
def sliding_create(seq_id, seq_str, start_pos, window_size):
# defines a function that takes the sequence id of the input query, the
# actual sequence from the fasta seq record, the start position (from the
# loop, for your sliding window, and the window size, from a command line
# paramter
sub_seq = seq_str[start_pos:start_pos + window_size]
# cut a sub sequence from the full length sequence, from the start
# position (of this loop iteration) + the window length
sub_pos_str = str(seq_id + "_POS:_" + str(start_pos) +
":" + str(start_pos + window_size))
# and create a string with the appropriate name so you know which window
# you test
if len(sub_seq) == window_size:
# only report the sub sequence if it is as long as the window size,
# otherwise you get shorter pieces at the end
return ">" + sub_pos_str + "\n" + sub_seq
else:
return None
# main loop begins here
with open(sys.argv[1] + "_sliding_window.fa", "w") as writefile:
# open our output file, same name as the input + the suffix
# _sliding_window.fa
for i in range(len(fcontent[0].seq)):
# for all positions in your sequence
output = sliding_create(fcontent[0].id, fcontent[
0].seq, i, int(sys.argv[2]))
# get the output of the function, as paramtere give the ID of the
# fasta record, the sequence of the fasta record, the current
# iteration of the loop (so we shift the window per one per loop,
# and how long you want your window to be.
if output != None:
# only have output if there is output, otherwise you get lots
# of empty output from the function when the sub sequence is no
# longer long enough. Write it into the output file.
writefile.write(str(output) + "\n")
| mit | -8,909,885,774,297,362,000 | 39.080645 | 91 | 0.646278 | false |
open-synergy/vertical-association | membership_autoextend/models/product_template.py | 1 | 1383 | # -*- coding: utf-8 -*-
# © 2016 Therp BV <http://therp.nl>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openerp import fields, models
class ProductTemplate(models.Model):
_inherit = 'product.template'
membership_autoextend = fields.Boolean('Autoextend membership',
default=False)
membership_autoextend_product_id = fields.Many2one(
'product.template', string='Extension membership',
help='If selected, use this product for extensions. Otherwise, the '
'current membership product will be used.',
domain=[('membership', '=', True)])
membership_autoextend_warning_days = fields.Integer(
'Warn before autoextend', help='The amount of days to send warning '
'email before automatic extension')
membership_autoextend_warning_template_id = fields.Many2one(
'email.template', string='Autoextend warning',
help='This email is sent the selected amount of days before a '
'membership was extended',
domain=[('model_id.model', '=', 'membership.membership_line')])
membership_autoextend_info_template_id = fields.Many2one(
'email.template', string='Autoextend info',
help='This email is sent after a membership was extended',
domain=[('model_id.model', '=', 'membership.membership_line')])
| agpl-3.0 | -2,176,540,284,076,027,100 | 48.357143 | 76 | 0.65919 | false |
matthewkitching/constraint_local_search | constraints/alldiff.py | 1 | 1294 | from constraints.base_constraint import BaseConstraint
from collections import defaultdict
class AllDifferent(BaseConstraint):
def __init__(self, variables, identifier=None):
'''
AllDifferent is satisfied if every variable is assigned a different
value.
The moves_necessary is equal to the total number of variables that
have the same value as other variables ignoring one of the duplicates)
'''
super(AllDifferent, self).__init__(variables, identifier)
self._reinit()
def _reinit(self):
self.score_count = defaultdict(int)
for variable in self.variables:
self.score_count[variable.state] += 1
self.moves_necessary = len(self.variables) - len(self.score_count)
def get_delta_moves_necessary(self, variable, new_value):
delta_old = 0 if self.score_count[variable.state] == 1 else -1
delta_new = 0 if self.score_count.get(new_value, 0) == 0 else 1
return delta_new + delta_old
def make_move(self, variable, new_value):
self.score_count[variable.state] -= 1
self.score_count[new_value] += 1
delta_moves = self.get_delta_moves_necessary(variable, new_value)
self.moves_necessary += delta_moves
return delta_moves
| gpl-2.0 | -7,278,428,690,419,748,000 | 39.4375 | 78 | 0.659969 | false |
noba3/KoTos | addons/plugin.video.mediathek/mediathek/kika.py | 1 | 6715 | # -*- coding: utf-8 -*-
#-------------LicenseHeader--------------
# plugin.video.Mediathek - Gives access to most video-platforms from German public service broadcasters
# Copyright (C) 2010 Raptor 2101 [[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/>.
import re, time;
from mediathek import *
class KIKA(Mediathek):
def __init__(self, simpleXbmcGui):
self.gui = simpleXbmcGui;
self.rootLink = "http://www.kika.de";
self.menuTree = (
TreeNode("0","Videos",self.rootLink+"/videos/index.html",True),
TreeNode("1","Sendungen von A-Z","",False,
(
TreeNode("1.0","A",self.rootLink+"/sendungen/sendungenabisz100_page-A_zc-05fb1331.html",True),
TreeNode("1.1","B",self.rootLink+"/sendungen/sendungenabisz100_page-B_zc-1775e6d8.html",True),
TreeNode("1.2","C",self.rootLink+"/sendungen/sendungenabisz100_page-C_zc-6248eba0.html",True),
TreeNode("1.3","D",self.rootLink+"/sendungen/sendungenabisz100_page-D_zc-e090a8fb.html",True),
TreeNode("1.4","E",self.rootLink+"/sendungen/sendungenabisz100_page-E_zc-ec2376ed.html",True),
TreeNode("1.5","F",self.rootLink+"/sendungen/sendungenabisz100_page-F_zc-f76734a0.html",True),
TreeNode("1.6","G",self.rootLink+"/sendungen/sendungenabisz100_page-G_zc-34bda7c3.html",True),
TreeNode("1.7","H",self.rootLink+"/sendungen/sendungenabisz100_page-H_zc-7e25e70a.html",True),
TreeNode("1.8","I",self.rootLink+"/sendungen/sendungenabisz100_page-I_zc-b7f774f5.html",True),
TreeNode("1.9","J",self.rootLink+"/sendungen/sendungenabisz100_page-J_zc-3130680a.html",True),
TreeNode("1.10","K",self.rootLink+"/sendungen/sendungenabisz100_page-K_zc-c8f76ba1.html",True),
TreeNode("1.11","L",self.rootLink+"/sendungen/sendungenabisz100_page-L_zc-bbebc1a7.html",True),
TreeNode("1.12","M",self.rootLink+"/sendungen/sendungenabisz100_page-M_zc-00574a43.html",True),
TreeNode("1.13","N",self.rootLink+"/sendungen/sendungenabisz100_page-N_zc-b079366f.html",True),
TreeNode("1.14","O",self.rootLink+"/sendungen/sendungenabisz100_page-O_zc-febc55f5.html",True),
TreeNode("1.15","P",self.rootLink+"/sendungen/sendungenabisz100_page-P_zc-2c1a492f.html",True),
TreeNode("1.16","Q",self.rootLink+"/sendungen/sendungenabisz100_page-Q_zc-2cb019d6.html",True),
TreeNode("1.17","R",self.rootLink+"/sendungen/sendungenabisz100_page-R_zc-cab3e22b.html",True),
TreeNode("1.18","S",self.rootLink+"/sendungen/sendungenabisz100_page-S_zc-e7f420d0.html",True),
TreeNode("1.19","T",self.rootLink+"/sendungen/sendungenabisz100_page-T_zc-84a2709f.html",True),
TreeNode("1.20","U",self.rootLink+"/sendungen/sendungenabisz100_page-U_zc-a26c1157.html",True),
TreeNode("1.21","V",self.rootLink+"/sendungen/sendungenabisz100_page-V_zc-1fc26dc3.html",True),
TreeNode("1.22","W",self.rootLink+"/sendungen/sendungenabisz100_page-W_zc-25c5c777.html",True),
TreeNode("1.23","Y",self.rootLink+"/sendungen/sendungenabisz100_page-Y_zc-388beba7.html",True),
TreeNode("1.24","Z",self.rootLink+"/sendungen/sendungenabisz100_page-Z_zc-e744950d.html",True),
TreeNode("1.25","...",self.rootLink+"/sendungen/sendungenabisz100_page-1_zc-43c28d56.html",True)
)
)
)
self.regex_videoPages=re.compile("<a href=\"(.*?sendereihe\\d+.html)\" class=\"linkAll\" title=\"(.*?)\">");
self.regex_videoLinks=re.compile("<a href=\"(.*?/sendungen/videos/video\\d+?)\\.html\"");
self.regex_xml_title=re.compile("<title>(.*?)</title>");
self.regex_xml_image=re.compile("<teaserimage>\\s*?<url>(.*?)</url>");
self.regex_xml_videoLink=re.compile("<asset>\\s*?<profileName>(.*?)</profileName>.*?<progressiveDownloadUrl>(.*?)</progressiveDownloadUrl>\\s*?</asset>",re.DOTALL)
self.regex_videoLink=re.compile("rtmp://.*?\.mp4");
@classmethod
def name(self):
return "KI.KA";
def isSearchable(self):
return False;
def searchVideo(self, searchText):
return;
def buildVideoLink(self,pageLink):
xmlPage = self.loadPage(self.rootLink+pageLink);
title = unicode(self.regex_xml_title.search(xmlPage).group(1),"UTF-8");
image = self.regex_xml_image.search(xmlPage).group(1).replace("**aspectRatio**","tlarge169").replace("**width**","1472");
self.gui.log("%s %s"%(title,image));
links = {};
for match in self.regex_xml_videoLink.finditer(xmlPage):
profile = match.group(1);
directLink = match.group(2);
self.gui.log("%s %s"%(profile,directLink));
if("MP4 Web S" in profile):
links[0] = SimpleLink(directLink, 0);
if("MP4 Web L" in profile):
links[1] = SimpleLink(directLink, 0);
if("MP4 Web L+" in profile):
links[2] = SimpleLink(directLink, 0);
if("MP4 Web XL" in profile):
links[3] = SimpleLink(directLink, 0);
return DisplayObject(title,"",image,"",links,True, None);
def buildPageMenu(self, link, initCount):
mainPage = self.loadPage(link);
videoLinks = list(self.regex_videoLinks.finditer(mainPage));
count = initCount + len(videoLinks)
if(len(videoLinks) > 0):
for match in videoLinks:
link=match.group(1)+"-avCustom.xml";
displayObject = self.buildVideoLink(link);
self.gui.buildVideoLink(displayObject,self, count);
else:
videoPages = list(self.regex_videoPages.finditer(mainPage));
count = initCount + len(videoPages)
for match in videoPages:
link=match.group(1);
if(not link.startswith(self.rootLink)):
link = self.rootLink+link;
subPage = self.loadPage(link);
linkFound = self.regex_videoLinks.search(subPage)
if(linkFound):
title = unicode(match.group(2),"UTF-8");
displayObject = DisplayObject(title,"",None,"",link,False, None);
self.gui.buildVideoLink(displayObject,self, count);
| gpl-2.0 | -5,218,597,951,839,051,000 | 51.46875 | 167 | 0.651378 | false |
lkundrak/scraperwiki | services/jdatastore/datalib.py | 1 | 22102 | from twisted.python import log
import ConfigParser
import hashlib
import types
import os, string, re, sys
import time, datetime
import sqlite3
import base64
import shutil
import logging
import urllib
import traceback
import json
import csv
import StringIO
from twisted.internet import reactor
logger = None # filled in by dataproxy
ninstructions_progresshandler = 10000000 # about 0.4secs on Julian's laptop
resourcedir = None # filled in by dataproxy
attachauthurl = None # filled in by dataproxy
def authorizer_readonly(action_code, tname, cname, sql_location, trigger):
#logger.debug("authorizer_readonly: %s, %s, %s, %s, %s" % (action_code, tname, cname, sql_location, trigger))
readonlyops = [ sqlite3.SQLITE_SELECT, sqlite3.SQLITE_READ, sqlite3.SQLITE_DETACH, 31 ] # 31=SQLITE_FUNCTION missing from library. codes: http://www.sqlite.org/c3ref/c_alter_table.html
if action_code in readonlyops:
return sqlite3.SQLITE_OK
if action_code == sqlite3.SQLITE_PRAGMA:
if tname in ["table_info", "index_list", "index_info", "page_size"]:
return sqlite3.SQLITE_OK
# SQLite FTS (full text search) requires this permission even when reading, and
# this doesn't let ordinary queries alter sqlite_master because of PRAGMA writable_schema
if action_code == sqlite3.SQLITE_UPDATE and tname == "sqlite_master":
return sqlite3.SQLITE_OK
return sqlite3.SQLITE_DENY
def authorizer_attaching(action_code, tname, cname, sql_location, trigger):
#print "authorizer_attaching", (action_code, tname, cname, sql_location, trigger)
if action_code == sqlite3.SQLITE_ATTACH:
return sqlite3.SQLITE_OK
return authorizer_readonly(action_code, tname, cname, sql_location, trigger)
def authorizer_writemain(action_code, tname, cname, sql_location, trigger):
#logger.debug("authorizer_writemain: %s, %s, %s, %s, %s" % (action_code, tname, cname, sql_location, trigger))
if sql_location == None or sql_location == 'main':
return sqlite3.SQLITE_OK
return authorizer_readonly(action_code, tname, cname, sql_location, trigger)
#http://twistedmatrix.com/documents/current/core/howto/producers.html
class SQLiteDatabase(object):
def __init__(self, short_name, short_name_dbreadonly, attachlist):
self.Dclientnumber = -1
self.short_name = short_name
self.short_name_dbreadonly = short_name_dbreadonly
self.attachlist = attachlist # to be used to drive the attaches on setup
self.attached = { } # name => [ asname1, ... ] list
self.m_sqlitedbconn = None
self.m_sqlitedbcursor = None
self.authorizer_func = None
self.sqlitesaveinfo = { } # tablename -> info
if self.short_name:
self.scraperresourcedir = os.path.join(resourcedir, self.short_name)
self.cstate = ''
self.etimestate = time.time()
self.progressticks = 0
self.totalprogressticks = 0
self.timeout_tickslimit = 300 # about 2 minutes
self.timeout_secondslimit = 180 # real time
self.clientforresponse = None
def close(self):
logger.debug("client#%d calling close on database" % self.Dclientnumber)
try:
if self.m_sqlitedbcursor:
self.m_sqlitedbcursor.close()
if self.m_sqlitedbconn:
self.m_sqlitedbconn.close()
except Exception, e:
logger.warning("client#%d close database error: %s" % (self.Dclientnumber, str(e)))
def process(self, request):
#logger.debug("doing request %s" % str(request)[:1000])
if request["maincommand"] == 'save_sqlite':
res = self.save_sqlite(unique_keys=request["unique_keys"], data=request["data"], swdatatblname=request["swdatatblname"])
logger.debug("save_sqlite response %s" % str(res))
elif request["maincommand"] == 'clear_datastore':
res = self.clear_datastore()
elif request["maincommand"] == 'undelete_datastore':
res = self.undelete_datastore()
elif request["maincommand"] == 'sqlitecommand':
if request["command"] == "downloadsqlitefile":
res = self.downloadsqlitefile(seek=request["seek"], length=request["length"])
elif request["command"] == "datasummary":
res = self.datasummary(request.get("limit", 10))
else:
res = {"error":'Unknown command: %s' % request["command"]}
elif request["maincommand"] == "sqliteexecute":
if self.attachlist:
self.establishconnection(True)
for req in self.attachlist:
if req["asname"] not in self.attached.get(req["name"], []):
ares = self.sqliteattach(req["name"], req["asname"])
if "error" in ares:
return ares
self.cstate, self.etimestate = 'sqliteexecute', time.time()
res = self.sqliteexecute(sqlquery=request["sqlquery"], data=request["data"])
if 'error' not in res:
res["stillproducing"] = "yes"
else:
res = {"error":'Unknown maincommand: %s' % request["maincommand"]}
logger.debug(json.dumps(res))
return res
def undelete_datastore(self):
restore_from = os.path.join(self.scraperresourcedir, "DELETED-defaultdb.sqlite")
if os.path.isfile(restore_from):
restore_to = os.path.join(self.scraperresourcedir, "defaultdb.sqlite")
shutil.move(restore_from, restore_to)
return {"status":"good"}
def clear_datastore(self):
scrapersqlitefile = os.path.join(self.scraperresourcedir, "defaultdb.sqlite")
if os.path.isfile(scrapersqlitefile):
deletedscrapersqlitefile = os.path.join(self.scraperresourcedir, "DELETED-defaultdb.sqlite")
shutil.move(scrapersqlitefile, deletedscrapersqlitefile)
return {"status":"good"}
# To do this properly would need to ensure file doesn't change during this process
def downloadsqlitefile(self, seek, length):
self.cstate, self.etimestate = 'downloadsqlitefile', time.time()
scrapersqlitefile = os.path.join(self.scraperresourcedir, "defaultdb.sqlite")
lscrapersqlitefile = os.path.join(self.short_name, "defaultdb.sqlite")
if not os.path.isfile(scrapersqlitefile):
return {"status":"No sqlite database"}
result = { "filename":lscrapersqlitefile, "filesize": os.path.getsize(scrapersqlitefile)}
if length == 0:
return result
fin = open(scrapersqlitefile, "rb")
fin.seek(seek)
content = fin.read(length)
result["length"] = len(content)
result["content"] = base64.encodestring(content)
result['encoding'] = "base64"
fin.close()
return result
def establishconnection(self, bcreate):
# seems not able to reset authorizer function after it has been set once, so have to redirect this way
def authorizer_all(action_code, tname, cname, sql_location, trigger):
#print "authorizer_all", (action_code, tname, cname, sql_location, trigger)
return self.authorizer_func(action_code, tname, cname, sql_location, trigger)
if self.short_name_dbreadonly:
self.authorizer_func = authorizer_readonly
else:
self.authorizer_func = authorizer_writemain
if not self.m_sqlitedbconn:
if self.short_name:
if not os.path.isdir(self.scraperresourcedir):
if not bcreate:
return False
os.mkdir(self.scraperresourcedir)
scrapersqlitefile = os.path.join(self.scraperresourcedir, "defaultdb.sqlite")
self.m_sqlitedbconn = sqlite3.connect(scrapersqlitefile, check_same_thread=False)
logger.debug('Connecting to %s' % (scrapersqlitefile))
else:
self.m_sqlitedbconn = sqlite3.connect(":memory:", check_same_thread=False) # draft scrapers make a local version
if not self.short_name_dbreadonly:
self.m_sqlitedbconn.isolation_level = None # autocommit!
self.m_sqlitedbconn.set_authorizer(authorizer_all)
if ninstructions_progresshandler:
self.m_sqlitedbconn.set_progress_handler(self.progress_handler, ninstructions_progresshandler)
self.m_sqlitedbcursor = self.m_sqlitedbconn.cursor()
return True
def datasummary(self, limit):
self.cstate, self.etimestate = 'datasummary', time.time()
if not self.establishconnection(False):
logger.warning( 'Failed to connect to sqlite database for summary %s' % (self.short_name or 'draft'))
return {"status":"No sqlite database"} # don't change this return string, is a structured one
logger.debug('Performing datasummary for %s' % self.short_name)
self.authorizer_func = authorizer_readonly
total_rows = 0
tables = { }
try:
for name, sql in list(self.m_sqlitedbcursor.execute("select name, sql from sqlite_master where type='table' or type='view'")):
tables[name] = {"sql":sql}
cols = []
self.m_sqlitedbcursor.execute("PRAGMA table_info(`%s`);" % name)
# We can optimise the count by doing all tables in sub-selects, but suspect it is a micro-optimisation
tables[name]["keys"] = [ r[1] for r in self.m_sqlitedbcursor]
tables[name]["count"] = list(self.m_sqlitedbcursor.execute("select count(1) from `%s`" % name))[0][0]
total_rows += int(tables[name]["count"])
except sqlite3.Error, e:
return {"error":"datasummary: sqlite3.Error: "+str(e)}
result = {"tables":tables, 'total_rows': total_rows }
if self.short_name:
scrapersqlitefile = os.path.join(self.scraperresourcedir, "defaultdb.sqlite")
if os.path.isfile(scrapersqlitefile):
result["filesize"] = os.path.getsize(scrapersqlitefile)
return result
def sqliteattach(self, name, asname):
logger.debug("attach to %s %s as %s" % (self.short_name, name, asname))
self.establishconnection(True)
if self.authorizer_func == authorizer_writemain:
self.m_sqlitedbconn.commit() # otherwise a commit will be invoked by the attaching function
logger.info("requesting permission to attach %s to %s" % (self.short_name, name))
aquery = {"command":"can_attach", "scrapername":self.short_name, "attachtoname":name, "username":"unknown"}
ares = urllib.urlopen("%s?%s" % (attachauthurl, urllib.urlencode(aquery))).read()
logger.info("permission to attach %s to %s response: %s" % (self.short_name, name, ares))
if ares == "Yes":
logger.debug('attach connection allowed')
elif ares == "DoesNotExist":
return {"error":"Does Not Exist %s" % name}
else:
return {"error":"no permission to attach to %s" % name}
attachscrapersqlitefile = os.path.join(resourcedir, name, "defaultdb.sqlite")
self.authorizer_func = authorizer_attaching
try:
self.m_sqlitedbcursor.execute('attach database ? as ?', (attachscrapersqlitefile, asname or name))
except sqlite3.Error, e:
logger.error(e)
return {"error":"sqliteattach: sqlite3.Error: "+str(e)}
logger.debug('attach complete')
if name not in self.attached:
self.attached[name] = [ ]
self.attached[name].append(asname)
return {"status":"attach succeeded"}
def progress_handler(self):
if self.cstate == 'sqliteexecute':
self.progressticks += 1
self.totalprogressticks += 1
if self.progressticks == self.timeout_tickslimit:
logger.info("client#%d tickslimit timeout" % (self.Dclientnumber))
return 1
if time.time() - self.etimestate > self.timeout_secondslimit:
logger.info("client#%d elapsed time timeout" % (self.Dclientnumber))
return 2
logger.debug("client#%d progress %d time=%.2f" % (self.Dclientnumber, self.progressticks, time.time() - self.etimestate))
# looks like should be using IBodyPushProducer for this cycle
# but prob couldn't work as we are in a deferred thread here
lclientforresponse = self.clientforresponse
if not lclientforresponse:
logger.info("client#%d terminating progress" % (self.Dclientnumber)) # as nothing to receive the result anyway
return 3
elif lclientforresponse.progress_ticks == "yes":
jtickline = json.dumps({"progresstick":self.progressticks, "timeseconds":time.time() - self.etimestate})+"\n"
# should this be using IPushProducer?
reactor.callFromThread(lclientforresponse.transport.write, jtickline)
return 0 # continue
def sqliteexecute(self, sqlquery, data):
self.establishconnection(True)
self.progressticks = 0
try:
logger.info("client#%d sqlexecute %s" % (self.Dclientnumber, str(sqlquery)[:100]))
if data:
self.m_sqlitedbcursor.execute(sqlquery, data) # handle "(?,?,?)", (val, val, val)
else:
self.m_sqlitedbcursor.execute(sqlquery)
logger.info("client#%d end-sqlexecute %f" % (self.Dclientnumber, time.time() - self.etimestate))
# take a copy of the clientforresponse as it may be disconnected by the other thread
lclientforresponse = self.clientforresponse
if not lclientforresponse:
return {"error":"client must have disconnected"}
keys = self.m_sqlitedbcursor.description and map(lambda x:x[0], self.m_sqlitedbcursor.description) or []
arg = {"keys":keys, "data":[] } # data empty for filling in in another function
except sqlite3.Error, e:
arg = {"error":"sqliteexecute: sqlite3.Error: %s" % str(e)}
except ValueError, ve:
arg = {"error":"sqliteexecute: ValueError: %s" % str(ve)}
if "error" in arg:
logger.error(arg["error"])
arg["progressticks"] = self.progressticks
arg["timeseconds"] = time.time() - self.etimestate
return arg
def save_sqlite(self, unique_keys, data, swdatatblname):
self.cstate, self.etimestate = 'save_sqlite', time.time()
res = { }
if type(data) == dict:
data = [data]
if not self.m_sqlitedbconn or swdatatblname not in self.sqlitesaveinfo:
ssinfo = SqliteSaveInfo(self, swdatatblname)
self.sqlitesaveinfo[swdatatblname] = ssinfo
if not ssinfo.rebuildinfo() and data:
ssinfo.buildinitialtable(data[0])
ssinfo.rebuildinfo()
res["tablecreated"] = swdatatblname
else:
ssinfo = self.sqlitesaveinfo[swdatatblname]
nrecords = 0
self.sqliteexecute("BEGIN TRANSACTION", None)
logger.debug("client#%d begintrans for records %d" % (self.Dclientnumber, len(data)))
for ldata in data:
newcols = ssinfo.newcolumns(ldata)
if newcols:
for i, kv in enumerate(newcols):
ssinfo.addnewcolumn(kv[0], kv[1])
res["newcolumn %d" % i] = "%s %s" % kv
ssinfo.rebuildinfo()
if nrecords == 0 and unique_keys:
idxname, idxkeys = ssinfo.findclosestindex(unique_keys)
if not idxname or idxkeys != set(unique_keys):
lres = ssinfo.makenewindex(idxname, unique_keys)
if "error" in lres:
return lres
res.update(lres)
values = [ ldata.get(k) for k in ssinfo.swdatakeys ]
lres = self.sqliteexecute(ssinfo.sqdatatemplate, values)
if "error" in lres:
return lres
nrecords += 1
logger.debug("client#%d about to endtrans" % (self.Dclientnumber))
self.sqliteexecute("END TRANSACTION", None)
logger.debug("client#%d endtrans" % (self.Dclientnumber))
#self.m_sqlitedbconn.commit()
res["nrecords"] = nrecords
res["status"] = 'Data record(s) inserted or replaced'
self.cstate = ''
return res
def FetchRows(self, nrows=-1):
rows = []
for r in self.m_sqlitedbcursor:
row = []
for c in r:
if type(c) == buffer:
row.append( unicode(c) )
else:
row.append(c)
rows.append(row)
if nrows != -1 and len(rows) == nrows:
break
return rows
class SqliteSaveInfo:
def __init__(self, database, swdatatblname):
self.database = database
self.swdatatblname = swdatatblname
self.swdatakeys = [ ]
self.swdatatypes = [ ]
self.sqdatatemplate = ""
def sqliteexecuteSS(self, sqlquery, data=None):
res = self.database.sqliteexecute(sqlquery, data)
if "error" in res:
logger.warning("%s %s" % (self.database.short_name, str(res)[:1000]))
res["data"] = self.database.FetchRows()
return res
def rebuildinfo(self):
if not self.sqliteexecuteSS("select * from main.sqlite_master where name=?", (self.swdatatblname,))['data']:
return False
tblinfo = self.sqliteexecuteSS("PRAGMA main.table_info(`%s`)" % self.swdatatblname)
# there's a bug: PRAGMA main.table_info(swdata) returns the schema for otherdatabase.swdata
# following an attach otherdatabase where otherdatabase has a swdata and main does not
self.swdatakeys = [ a[1] for a in tblinfo["data"] ]
self.swdatatypes = [ a[2] for a in tblinfo["data"] ]
self.sqdatatemplate = "insert or replace into main.`%s` values (%s)" % (self.swdatatblname, ",".join(["?"]*len(self.swdatakeys)))
return True
def buildinitialtable(self, data):
assert not self.swdatakeys
coldef = self.newcolumns(data)
assert coldef
# coldef = coldef[:1] # just put one column in; the rest could be altered -- to prove it's good
scoldef = ", ".join(["`%s` %s" % col for col in coldef])
# used to just add date_scraped in, but without it can't create an empty table
self.sqliteexecuteSS("create table main.`%s` (%s)" % (self.swdatatblname, scoldef))
def newcolumns(self, data):
newcols = [ ]
for k in data:
if k not in self.swdatakeys:
v = data[k]
if v != None:
if k[-5:] == "_blob":
vt = "blob" # coerced into affinity none
elif type(v) == int:
vt = "integer"
elif type(v) == float:
vt = "real"
else:
vt = "text"
newcols.append((k, vt))
return newcols
def addnewcolumn(self, k, vt):
self.sqliteexecuteSS("alter table main.`%s` add column `%s` %s" % (self.swdatatblname, k, vt))
def findclosestindex(self, unique_keys):
idxlist = self.sqliteexecuteSS("PRAGMA main.index_list(`%s`)" % self.swdatatblname) # [seq,name,unique]
uniqueindexes = [ ]
if 'error' in idxlist:
return None, None
for idxel in idxlist["data"]:
if idxel[2]:
idxname = idxel[1]
idxinfo = self.sqliteexecuteSS("PRAGMA main.index_info(`%s`)" % idxname) # [seqno,cid,name]
idxset = set([ a[2] for a in idxinfo["data"] ])
idxoverlap = len(idxset.intersection(unique_keys))
uniqueindexes.append((idxoverlap, idxname, idxset))
if not uniqueindexes:
return None, None
uniqueindexes.sort()
return uniqueindexes[-1][1], uniqueindexes[-1][2]
# increment to next index number every time there is a change, and add the new index before dropping the old one.
def makenewindex(self, idxname, unique_keys):
istart = 0
if idxname:
mnum = re.search("(\d+)$", idxname)
if mnum:
istart = int(mnum.group(1))
for i in range(10000):
newidxname = "%s_index%d" % (self.swdatatblname, istart+i)
if not self.sqliteexecuteSS("select name from main.sqlite_master where name=?", (newidxname,))['data']:
break
res = { "newindex": newidxname }
lres = self.sqliteexecuteSS("create unique index `%s` on `%s` (%s)" % (newidxname, self.swdatatblname, ",".join(["`%s`"%k for k in unique_keys])))
if "error" in lres:
return lres
if idxname:
lres = self.sqliteexecuteSS("drop index main.`%s`" % idxname)
if "error" in lres:
if lres["error"] != 'sqlite3.Error: index associated with UNIQUE or PRIMARY KEY constraint cannot be dropped':
return lres
logger.info("%s: %s" % (self.database.short_name, str(lres)[:1000]))
res["droppedindex"] = idxname
return res
| agpl-3.0 | -168,464,633,160,901,730 | 43.115768 | 190 | 0.588363 | false |
sebp/scikit-survival | doc/conf.py | 1 | 12316 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# scikit-survival documentation build configuration file
#
# 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.
from datetime import datetime
import inspect
import os
from pathlib import Path
import re
import sys
from nbconvert.preprocessors import Preprocessor
import nbsphinx
from setuptools_scm import get_version
# on_rtd is whether we are on readthedocs.org, this line of code grabbed from docs.readthedocs.org
# https://docs.readthedocs.io/en/latest/faq.html?highlight=environ#how-do-i-change-behavior-for-read-the-docs
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
# 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.
if on_rtd:
sys.path.insert(0, os.path.abspath(os.path.pardir))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
needs_sphinx = '1.8'
# 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.napoleon',
'sphinx.ext.autosummary',
'sphinx.ext.coverage',
'sphinx.ext.linkcode',
'sphinx.ext.mathjax',
'nbsphinx',
]
autosummary_generate = True
autodoc_default_options = {
'members': None,
'inherited-members': None,
}
# Napoleon settings
napoleon_google_docstring = False
napoleon_include_init_with_doc = False
# 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 = 'scikit-survival'
current_year = datetime.utcnow().year
copyright = f'2015-{current_year}, Sebastian Pölsterl and contributors'
# 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 full version, including alpha/beta/rc tags.
if on_rtd:
release = get_version(root='..', relative_to=__file__)
else:
import sksurv
release = sksurv.__version__
# The short X.Y.Z version.
version = '.'.join(release.split('.')[:3])
# 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'
# The default language to highlight source code in.
highlight_language = 'none'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build', '**/README.*', 'Thumbs.db', '.DS_Store']
# 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
nbsphinx_execute = 'never'
nbsphinx_prolog = r"""
{% set docname = "doc/" + env.doc2path(env.docname, base=None) %}
{% set notebook = env.doc2path(env.docname, base=None)|replace("user_guide/", "notebooks/") %}
{% set branch = 'master' if 'dev' in env.config.release else 'v{}'.format(env.config.release) %}
.. raw:: html
<div class="admonition note" style="line-height: 150%;">
This page was generated from
<a class="reference external" href="https://github.com/sebp/scikit-survival/blob/{{ branch|e }}/{{ docname|e }}">{{ docname|e }}</a>.<br/>
Interactive online version:
<span style="white-space: nowrap;"><a href="https://mybinder.org/v2/gh/sebp/scikit-survival/{{ branch|e }}?urlpath=lab/tree/{{ notebook|e }}"><img alt="Binder badge" src="https://mybinder.org/badge_logo.svg" style="vertical-align:text-bottom"></a>.</span>
</div>
"""
# -- 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 = 'pydata_sphinx_theme'
# 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 = {
"github_url": "https://github.com/sebp/scikit-survival",
}
# 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 = "scikit-survival {0}".format(version)
# 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
html_css_files = ['custom.css']
html_js_files = ['buttons.js']
# 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']
def linkcode_resolve(domain, info):
"""
Determine the URL corresponding to Python object
Adapted from scipy.
"""
import sksurv
if domain != 'py':
return None
modname = info['module']
fullname = info['fullname']
submod = sys.modules.get(modname)
if submod is None:
return None
obj = submod
for part in fullname.split('.'):
try:
obj = getattr(obj, part)
except AttributeError:
return None
try:
fn = inspect.getsourcefile(obj)
except TypeError:
fn = None
if fn is None and hasattr(obj, '__module__'):
fn = inspect.getsourcefile(sys.modules[obj.__module__])
if fn is None:
return None
try:
source, lineno = inspect.getsourcelines(obj)
except ValueError:
lineno = None
if lineno:
linespec = '#L%d-L%d' % (lineno, lineno + len(source) - 1)
else:
linespec = ''
startdir = Path(sksurv.__file__).parent.parent.absolute()
if not fn.startswith(str(startdir)): # not in sksurv
return None
fn = '/'.join(Path(fn).relative_to(startdir).parts)
if fn.startswith('sksurv/'):
m = re.match(r'^.*dev[0-9]+\+g([a-f0-9]+)$', release)
if m:
branch = m.group(1)
elif 'dev' in release:
branch = 'master'
else:
branch = 'v{}'.format(release)
return 'https://github.com/sebp/scikit-survival/blob/{branch}/{filename}{linespec}'.format(
branch=branch,
filename=fn,
linespec=linespec
)
else:
return None
class RTDUrlPreprocessor(Preprocessor):
"""Convert URLs to RTD in notebook to relative urls."""
URL_PATTERN = re.compile(
r'\(https://scikit-survival\.readthedocs\.io/.+?/.+?/([-._a-zA-Z0-9/]+)/(.+?)\.html.*?\)'
)
DOC_DIR = Path(__file__).parent
def preprocess_cell(self, cell, resources, index):
# path of notebook directory, relative to conf.py
nb_path = Path(resources['metadata']['path']).relative_to(self.DOC_DIR)
to_root = [os.pardir] * len(nb_path.parts)
if cell.cell_type == 'markdown':
text = cell.source
replace = []
for match in self.URL_PATTERN.finditer(text):
path = to_root[:]
path.append(match.group(1))
rel_url = "/".join(path)
filename = match.group(2)
replace.append((match.group(0), '({}/{}.rst)'.format(rel_url, filename)))
for s, r in replace:
text = text.replace(s, r)
cell.source = text
return cell, resources
return cell, resources
def _from_notebook_node(self, nb, resources, **kwargs):
filters = [RTDUrlPreprocessor(), ]
for f in filters:
nb, resources = f.preprocess(nb, resources=resources)
return nbsphinx_from_notebook_node(self, nb, resources=resources, **kwargs)
# see https://github.com/spatialaudio/nbsphinx/issues/305#issuecomment-506748814-permalink
nbsphinx_from_notebook_node = nbsphinx.Exporter.from_notebook_node
nbsphinx.Exporter.from_notebook_node = _from_notebook_node
# ------------------------
# Mock dependencies on RTD
# ------------------------
if on_rtd:
MOCK_MODULES = [
# external dependencies
'ecos',
'joblib',
'numexpr',
'numpy',
'osqp',
'pandas',
'pandas.api.types',
'scipy',
'scipy.integrate',
'scipy.io.arff',
'scipy.linalg',
'scipy.optimize',
'scipy.sparse',
'scipy.special',
'scipy.stats',
'sklearn',
'sklearn.base',
'sklearn.dummy',
'sklearn.ensemble',
'sklearn.ensemble._base',
'sklearn.ensemble._forest',
'sklearn.ensemble._gb',
'sklearn.ensemble._gb_losses',
'sklearn.ensemble._gradient_boosting',
'sklearn.ensemble.base',
'sklearn.ensemble.forest',
'sklearn.ensemble.gradient_boosting',
'sklearn.exceptions',
'sklearn.externals.joblib',
'sklearn.linear_model',
'sklearn.metrics',
'sklearn.metrics.pairwise',
'sklearn.model_selection',
'sklearn.pipeline',
'sklearn.preprocessing',
'sklearn.svm',
'sklearn.tree',
'sklearn.tree._classes',
'sklearn.tree._splitter',
'sklearn.tree._tree',
'sklearn.tree.tree',
'sklearn.utils',
'sklearn.utils._joblib',
'sklearn.utils.extmath',
'sklearn.utils.fixes',
'sklearn.utils.metaestimators',
'sklearn.utils.validation',
# our C modules
'sksurv.bintrees._binarytrees',
'sksurv.ensemble._coxph_loss',
'sksurv.kernels._clinical_kernel',
'sksurv.linear_model._coxnet',
'sksurv.svm._minlip',
'sksurv.svm._prsvm',
'sksurv.tree._criterion']
MOCK_VERSIONS = {
'pandas': '0.25.0',
'sklearn': '0.22.0',
}
from unittest.mock import Mock
class MockModule(Mock):
"""mock imports"""
@classmethod
def __getattr__(cls, name):
if name in ('__file__', '__path__'):
return '/dev/null'
elif name[0] == name[0].upper() and name[0] != "_":
# Not very good, we assume Uppercase names are classes...
mocktype = type(name, (), {})
mocktype.__module__ = __name__
return mocktype
else:
return MockModule()
sys.modules.update((mod_name, MockModule()) for mod_name in MOCK_MODULES)
for mod, ver in MOCK_VERSIONS.items():
setattr(sys.modules[mod], '__version__', ver)
| gpl-3.0 | -5,840,506,738,319,099,000 | 30.256345 | 261 | 0.633618 | false |
Marginal/OverlayEditor | draw.py | 1 | 94208 | import OpenGL # for __version__
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.arrays import vbo
from OpenGL.extensions import alternate, hasGLExtension
from OpenGL.GL.shaders import compileShader, compileProgram
from OpenGL.GL.ARB.occlusion_query import *
glBeginQuery = alternate(glBeginQuery, glBeginQueryARB)
glDeleteQueries = alternate(glDeleteQueries, glDeleteQueriesARB)
glEndQuery = alternate(glEndQuery, glEndQueryARB)
glGenQueries = alternate(glGenQueries, glGenQueriesARB)
glGetQueryObjectuiv = alternate(glGetQueryObjectuiv, glGetQueryObjectuivARB)
GL_ANY_SAMPLES_PASSED=0x8C2F # not in 3.0.1
from OpenGL.GL.ARB.instanced_arrays import glInitInstancedArraysARB, glVertexAttribDivisorARB
from OpenGL.GL.EXT.multi_draw_arrays import glMultiDrawArraysEXT
from OpenGL.GL.EXT.gpu_shader4 import glInitGpuShader4EXT
glMultiDrawArrays = alternate(glMultiDrawArrays, glMultiDrawArraysEXT)
import gc
from glob import glob
from math import atan2, cos, sin, floor, hypot, radians
from numpy import array, array_equal, concatenate, dot, identity, vstack, zeros, float32, float64, int32
import os
from os.path import basename, curdir, join, splitext
from struct import unpack
from sys import exc_info, exit, platform, version
from traceback import print_exc
import time
import wx
import wx.glcanvas
from apt import layoutApt
from files import VertexCache, sortfolded, glInitTextureCompressionS3TcEXT
from fixed8x13 import fixed8x13
from clutter import Clutter, Object, Polygon, Draped, DrapedImage, Facade, Network, Exclude
from clutterdef import ClutterDef, ObjectDef, AutoGenPointDef, NetworkDef, PolygonDef, COL_CURSOR, COL_SELECTED, COL_UNPAINTED, COL_DRAGBOX, COL_WHITE, fallbacktexture
from DSFLib import readDSF
from elevation import BBox, ElevationMesh, onedeg, round2res
from imagery import Imagery
from lock import Locked
from MessageBox import myMessageBox
from nodes import Node
from prefs import Prefs, prefs, gcustom, gnavdata
from version import appname
sband=16 # width of mouse scroll band around edge of window
debugapt = __debug__ and False
log_glstate= __debug__ and True
log_load = __debug__ and True
log_paint = __debug__ and False
class UndoEntry:
ADD=0
DEL=1
MODIFY=2
MOVE=3
SPLIT=4
def __init__(self, tile, kind, data):
self.tile=tile
self.kind=kind
self.data=data # [(idx, placement)]
def equals(self, other):
# ignore placement details
if self.tile!=other.tile or not (self.kind==other.kind==UndoEntry.MOVE): return False
if self.data==other.data==None: return True
if not (self.data and other.data and len(self.data)==len(other.data)):
return False
for i in range(len(self.data)):
if self.data[i][0]!=other.data[i][0]:
return False
return True
class ClickModes:
Undecided=1
DragBox=2
Drag=3
DragNode=4
Scroll=5
Move=6
# OpenGL state
class GLstate():
def __init__(self):
self.debug=__debug__ and False
self.proj = identity(4, float64) # projection matrix
self.occlusion_query=None # Will test for this later
self.queries=[]
self.multi_draw_arrays = bool(glMultiDrawArrays)
glEnableClientState(GL_VERTEX_ARRAY)
self.texture=0
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
self.color=COL_UNPAINTED
glColor3f(*COL_UNPAINTED)
glDisableClientState(GL_COLOR_ARRAY)
self.cull=True
glEnable(GL_CULL_FACE)
self.depthtest=True
glDepthFunc(GL_LESS)
self.poly=False
glDisable(GL_POLYGON_OFFSET_FILL)
glDepthMask(GL_TRUE)
self.current_vbo=None
self.instance_vbo =vbo.VBO(None, GL_STATIC_DRAW, size=0) # explicit size for PyOpenGL_accelerate
self.vector_vbo =vbo.VBO(None, GL_STATIC_DRAW, size=0)
self.vector_indices_vbo =vbo.VBO(None, GL_STATIC_DRAW, GL_ELEMENT_ARRAY_BUFFER, size=0)
self.dynamic_vbo =vbo.VBO(None, GL_STATIC_DRAW, size=0)
self.selected_vbo =vbo.VBO(None, GL_STREAM_DRAW, size=0)
# Use of GL_ARB_instanced_arrays requires a shader. Just duplicate fixed pipeline shaders.
try:
# MacOS 10.5 drivers are too flakey
if platform=='darwin' and int(os.uname()[2].split('.')[0]) < 10: raise NotImplementedError
vanilla = open('Resources/vanilla.vs').read()
instanced = open('Resources/instanced.vs').read()
unlit = open('Resources/unlit.fs').read()
colorvs = open('Resources/color.vs').read()
colorfs = open('Resources/color.fs').read()
pointfs = open('Resources/point.fs').read()
self.textureshader = compileProgram(compileShader(vanilla, GL_VERTEX_SHADER),
compileShader(unlit, GL_FRAGMENT_SHADER))
if __debug__: print glGetProgramInfoLog(self.textureshader)
self.transform_pos = glGetUniformLocation(self.textureshader, 'transform')
self.colorshader = compileProgram(compileShader(colorvs, GL_VERTEX_SHADER),
compileShader(colorfs, GL_FRAGMENT_SHADER))
if __debug__: print glGetProgramInfoLog(self.colorshader)
assert glGetProgramiv(self.colorshader, GL_LINK_STATUS), glGetProgramInfoLog(self.colorshader)
if platform=='win32' and glGetString(GL_VENDOR)=='Intel' and glGetString(GL_VERSION).startswith('2.'):
# gl_PointCoord broken on Gen5 and older - http://lists.freedesktop.org/archives/mesa-commit/2012-March/036247.html
self.pointshader = None
glPointSize(5.0)
else:
self.pointshader = compileProgram(compileShader(colorvs, GL_VERTEX_SHADER),
compileShader(pointfs, GL_FRAGMENT_SHADER))
if __debug__: print glGetProgramInfoLog(self.pointshader)
glEnable(GL_POINT_SPRITE)
if glInitInstancedArraysARB():
self.instancedshader = compileProgram(compileShader(instanced, GL_VERTEX_SHADER),
compileShader(unlit, GL_FRAGMENT_SHADER))
if __debug__: print glGetProgramInfoLog(self.instancedshader)
self.instanced_transform_pos = glGetAttribLocation(self.instancedshader, 'transform')
self.instanced_selected_pos = glGetAttribLocation(self.instancedshader, 'selected')
self.instanced_arrays = True
else:
self.instancedshader = self.instanced_transform_pos = self.instanced_selected_pos = None
self.instanced_arrays = False
glUseProgram(self.textureshader)
glUniform4f(self.transform_pos, *zeros(4,float32))
self.shaders = True
except:
if __debug__: print_exc()
self.instanced_arrays = self.shaders = False
self.textureshader = self.colorshader = self.pointshader = self.instancedshader = None
def set_texture(self, id):
if self.texture!=id:
if __debug__:
if self.debug: print "set_texture", id
if id is None:
if __debug__:
if self.debug: print "set_texture disable GL_TEXTURE_COORD_ARRAY"
glDisableClientState(GL_TEXTURE_COORD_ARRAY)
if self.shaders: glUseProgram(self.colorshader)
if self.texture!=0:
glBindTexture(GL_TEXTURE_2D, 0)
else:
if self.texture is None:
if __debug__:
if self.debug: print "set_texture enable GL_TEXTURE_COORD_ARRAY"
glEnableClientState(GL_TEXTURE_COORD_ARRAY)
if self.shaders: glUseProgram(self.textureshader)
glBindTexture(GL_TEXTURE_2D, id)
self.texture=id
elif __debug__:
if self.debug: print "set_texture already", id
def set_color(self, color):
if self.color!=color:
if color is None:
# Colors from VBO
if __debug__:
if self.debug:
print "set_color None"
print "set_color enable GL_COLOR_ARRAY"
glEnableClientState(GL_COLOR_ARRAY)
else:
# Color specified explicitly
if __debug__:
if self.debug: print "set_color (%.3f, %.3f. %.3f)" % color
if self.color is None:
if __debug__:
if self.debug: print "set_color disable GL_COLOR_ARRAY"
glDisableClientState(GL_COLOR_ARRAY)
glColor3f(*color)
self.color=color
elif __debug__:
if self.debug:
if self.color is None:
print "set_color already None"
else:
print "set_color already (%.3f, %.3f. %.3f)" % color
def set_depthtest(self, depthtest):
# Occlusion query counts "the number of samples that pass the depth and stencil tests", which ATI interpret
# as meaning that the depth test must be enabled. So control depth test via DepthFunc rather than glEnable.
if self.depthtest!=depthtest:
if __debug__:
if self.debug: print "set_depthtest", depthtest
self.depthtest=depthtest
if depthtest:
glDepthFunc(GL_LESS)
else:
glDepthFunc(GL_ALWAYS)
elif __debug__:
if self.debug: print "set_depthtest already", depthtest
def set_cull(self, cull):
if self.cull!=cull:
if __debug__:
if self.debug: print "set_cull", cull
self.cull=cull
if cull:
glEnable(GL_CULL_FACE)
else:
glDisable(GL_CULL_FACE)
elif __debug__:
if self.debug: print "set_cull already", cull
def set_poly(self, poly):
if self.poly!=poly:
if __debug__:
if self.debug: print "set_poly", poly
self.poly=poly
if poly:
glEnable(GL_POLYGON_OFFSET_FILL)
glDepthMask(GL_FALSE) # offset mustn't update depth
else:
glDisable(GL_POLYGON_OFFSET_FILL)
glDepthMask(GL_TRUE)
elif __debug__:
if self.debug: print "set_poly already", poly
def set_instance(self, vertexcache):
if vertexcache.realize_instance(self.instance_vbo) or self.current_vbo!=self.instance_vbo:
if __debug__:
if self.debug: print "set_instance"
self.instance_vbo.bind()
glTexCoordPointer(2, GL_FLOAT, 20, self.instance_vbo+12)
glVertexPointer(3, GL_FLOAT, 20, self.instance_vbo)
self.current_vbo=self.instance_vbo
elif __debug__:
if self.debug: print "set_instance already instance_vbo"
def set_vector(self, vertexcache):
if vertexcache.realize_vector(self.vector_vbo, self.vector_indices_vbo) or self.current_vbo!=self.vector_vbo:
if __debug__:
if self.debug: print "set_vector"
self.vector_indices_vbo.bind()
self.vector_vbo.bind()
glColorPointer(3, GL_FLOAT, 24, self.vector_vbo+12)
glVertexPointer(3, GL_FLOAT, 24, self.vector_vbo)
self.current_vbo=self.vector_vbo
elif __debug__:
if self.debug: print "set_vector already vector_vbo"
def set_dynamic(self, vertexcache):
if vertexcache.realize_dynamic(self.dynamic_vbo) or self.current_vbo!=self.dynamic_vbo:
if __debug__:
if self.debug: print "set_dynamic"
self.dynamic_vbo.bind()
glColorPointer(3, GL_FLOAT, 24, self.dynamic_vbo+12)
glTexCoordPointer(2, GL_FLOAT, 24, self.dynamic_vbo+12)
glVertexPointer(3, GL_FLOAT, 24, self.dynamic_vbo)
self.current_vbo=self.dynamic_vbo
elif __debug__:
if self.debug: print "set_dynamic already dynamic_vbo"
def set_attrib_selected(self, pos, selectflags):
self.selected_vbo.set_array(selectflags)
self.selected_vbo.bind()
glVertexAttribPointer(pos, 1, GL_FLOAT, GL_FALSE, 4, self.selected_vbo)
def alloc_queries(self, needed):
if len(self.queries)<needed:
if len(self.queries): glDeleteQueries(len(self.queries), self.queries)
needed=(needed/256+1)*256 # round up
self.queries=glGenQueries(needed)
if __debug__:
if self.debug: print "get_queries", self.queries
def pickmatrix(self, x, y, width, height, viewx, viewy):
# like gluPickMatrix, but doesn't actually load the resultant matrix into OpenGL
width = width and float(width) or 1.0 # maths goes wrong if zero-sized box
height = height and float(height) or 1.0
sx = viewx / width
sy = viewy / height
tx = (viewx - 2 * x) / width
ty = (viewy - 2 * y) / height
m = array([[sx, 0, 0, 0], [0, sy, 0, 0], [0, 0, 1, 0], [tx, ty, 0, 1]], dtype=float64)
return dot(self.proj, m)
# OpenGL Window
class MyGL(wx.glcanvas.GLCanvas):
def __init__(self, parent, frame):
self.parent=parent
self.frame=frame
self.movecursor=wx.StockCursor(wx.CURSOR_SIZING)
self.scrollcursor=wx.StockCursor(wx.CURSOR_HAND)
self.dragcursor=wx.StockCursor(wx.CURSOR_CROSS)
self.doneinit=False # Has glInit been called?
self.valid=False # do we have valid data for a redraw?
self.needclear=False # pending clear
self.needrefesh=False # pending refresh
self.options = 0 # display options at last goto()
self.tile=(0,999) # [lat,lon] of SW
self.centre=None # [lat,lon] of centre
self.airports={} # [runways] by code
self.runways={} # [shoulder/taxiway/runway data] by tile
self.aptdata = {} # indices into vertexcache (base, len), by layer
self.navaids=[] # (type, lat, lon, hdg)
self.navaidplacements={} # navaid placements by tile
self.codes={} # [(code, loc)] by tile
self.codeslist=0 # airport labels
self.lookup={} # virtual name -> filename (may be duplicates)
self.defs={} # loaded ClutterDefs by filename
self.placements={} # [Clutter] by tile
self.unsorted={} # [Clutter] by tile
self.background=None
self.mousenow=None # Current position (used in timer and drag)
self.locked=0 # locked object types
self.selected=set() # selected placements
self.clickmode=None
self.clickpos=None # Location of mouse down
self.clickctrl=False # Ctrl was held down
self.selectednode=None # Selected node. Only if len(self.selected)==1
self.selectedhandle=None # Selected node control handle.
self.selectedlayoutpending = False # self.clickmode==ClickModes.DragNode and we need to do a full layout
self.selections=set() # Hits for cycling picking
self.selectsaved=set() # Selection at start of ctrl drag box
self.snapnode = None # (Polygon, idx) of node we snapped to in ClickModes.DragNode mode
self.draginert=True
self.dragx=wx.SystemSettings_GetMetric(wx.SYS_DRAG_X)
self.dragy=wx.SystemSettings_GetMetric(wx.SYS_DRAG_Y)
if self.dragx<=1 or self.dragx>8 or self.dragy<=1 or self.dragy>8:
self.dragx=self.dragy=5 # Finder on Mac appears to use 5
self.clipboard = set()
self.undostack=[]
# Values during startup
self.x=0
self.y=0
self.z=0
self.h=0
self.e=45
self.d=2048.0
if __debug__: self.ei = self.ej = ElevationMesh.DIVISIONS/2-1 # for debugging elevation mesh
# Must specify min sizes for glX? - see glXChooseVisual and GLXFBConfig
try:
# Ask for a large depth buffer.
# wxGTK<=2.8 can't recover from a failure in glXChooseFBConfig so skip this - http://trac.wxwidgets.org/ticket/12479
if platform.startswith('linux'): raise AssertionError
# We're not using the stencil buffer so would prefer to specify a 32bit depth buffer, but this can cause e.g. Intel Windows drivers to fall back to 16 even though they support 24
wx.glcanvas.GLCanvas.__init__(self, parent, style=wx.FULL_REPAINT_ON_RESIZE|wx.WANTS_CHARS,
attribList=[wx.glcanvas.WX_GL_RGBA,wx.glcanvas.WX_GL_DOUBLEBUFFER,wx.glcanvas.WX_GL_DEPTH_SIZE, 24])
if wx.VERSION >= (2,9):
self.context = wx.glcanvas.GLContext(self)
except:
# Failed - try with safe 16bit depth buffer.
try:
if __debug__: print "Trying 16bit depth buffer"
# wxGTK<=2.8 has no way to discover if this fails, so will segfault later
wx.glcanvas.GLCanvas.__init__(self, parent, style=wx.FULL_REPAINT_ON_RESIZE|wx.WANTS_CHARS,
attribList=[wx.glcanvas.WX_GL_RGBA,wx.glcanvas.WX_GL_DOUBLEBUFFER,wx.glcanvas.WX_GL_DEPTH_SIZE, 16])
if wx.VERSION >= (2,9):
self.context = wx.glcanvas.GLContext(self)
except:
myMessageBox('Try updating the drivers for your graphics card.', "Can't initialise OpenGL.", wx.ICON_ERROR|wx.OK, frame)
exit(1)
# Allocate this stuff in glInit
self.glstate=None
self.vertexcache=None
wx.EVT_ERASE_BACKGROUND(self, self.OnEraseBackground)
wx.EVT_KEY_DOWN(self, self.OnKeyDown)
wx.EVT_MOUSEWHEEL(self, self.OnMouseWheel)
wx.EVT_MOTION(self, self.OnMouseMotion)
wx.EVT_LEFT_DOWN(self, self.OnLeftDown)
wx.EVT_LEFT_UP(self, self.OnLeftUp)
wx.EVT_MIDDLE_DOWN(self, self.OnMiddleDown)
wx.EVT_MIDDLE_UP(self, self.OnMiddleUp)
wx.EVT_IDLE(self, self.OnIdle)
#wx.EVT_KILL_FOCUS(self, self.OnKill) # debug
self.timer=wx.Timer(self, wx.ID_ANY)
wx.EVT_TIMER(self, self.timer.GetId(), self.OnTimer)
wx.EVT_PAINT(self, self.OnPaint)
def glInit(self):
# Setup state
if platform.startswith('linux') and not self.IsShownOnScreen():
return # Under X must be called after window is shown, which is deferred under wxGTK>=3.
else:
self.doneinit = True
if wx.VERSION >= (2,9):
self.SetCurrent(self.context)
else:
self.SetCurrent()
if log_glstate: print "%s\n%s\n%s\nRGBA: %d%d%d%d, Depth: %d, Stencil: %d, Aux: %d, DoubleBuffer: %d" % (glGetString(GL_VENDOR), glGetString(GL_RENDERER), glGetString(GL_VERSION), glGetInteger(GL_RED_BITS), glGetInteger(GL_GREEN_BITS), glGetInteger(GL_BLUE_BITS), glGetInteger(GL_ALPHA_BITS), glGetInteger(GL_DEPTH_BITS), glGetInteger(GL_STENCIL_BITS), glGetInteger(GL_AUX_BUFFERS), glGetBoolean(GL_DOUBLEBUFFER))
if not vbo.get_implementation():
myMessageBox('This application requires the use of OpenGL Vertex Buffer Objects (VBOs) which are not supported by your graphics card.\nTry updating the drivers for your graphics card.',
"Can't initialise OpenGL.", wx.ICON_ERROR|wx.OK, self.frame)
exit(1)
if not glInitTextureCompressionS3TcEXT() and not __debug__:
myMessageBox('This application requires the use of DXT texture compression which is not supported by your graphics card.\nTry updating the drivers for your graphics card.',
"Can't initialise OpenGL.", wx.ICON_ERROR|wx.OK, self.frame)
exit(1)
self.vertexcache=VertexCache() # member so can free resources
self.glstate=GLstate()
self.imagery=Imagery(self)
#glClearDepth(1.0)
glClearColor(0.5, 0.5, 1.0, 0.0) # Sky
glEnable(GL_DEPTH_TEST)
glShadeModel(GL_SMOOTH)
glEnable(GL_LINE_SMOOTH)
glPointSize(7.0) # for nodes
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST) # we can hope
glFrontFace(GL_CW)
glPolygonMode(GL_FRONT, GL_FILL)
glPolygonOffset(-2, -2)
glCullFace(GL_BACK)
glPixelStorei(GL_UNPACK_ALIGNMENT,1) # byte aligned glBitmap
glPixelStorei(GL_PACK_ALIGNMENT,1) # byte aligned glReadPixels
glReadBuffer(GL_BACK) # for unproject
#glPixelStorei(GL_UNPACK_LSB_FIRST,1)
glEnable(GL_TEXTURE_2D)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_BLEND)
glAlphaFunc(GL_GREATER, 1.0/256) # discard wholly transparent
glEnable(GL_ALPHA_TEST)
glMatrixMode(GL_TEXTURE)
glTranslatef(0, 1, 0)
glScalef(1, -1, 1) # OpenGL textures are backwards
glMatrixMode(GL_PROJECTION) # We always leave the modelview matrix as identity and the active matrix mode as projection, except briefly when drawing objects via the non-shader path
if log_glstate:
try:
import OpenGL_accelerate.formathandler # for py2exe
import OpenGL_accelerate.nones_formathandler # for py2exe
import OpenGL.acceleratesupport
print 'PyOpenGL acceleration:\t\t%s' % (OpenGL.acceleratesupport.ACCELERATE_AVAILABLE and 'yes' or 'no')
except:
print 'PyOpenGL acceleration:\t\tnot supported'
print 'max_texture_size:\t\t%d' % self.vertexcache.texcache.maxtexsize
print 'texture_non_power_of_two:\t%s' % (self.vertexcache.texcache.npot and 'yes' or 'no')
print 'texture_compression:\t\t%s' % (self.vertexcache.texcache.compress and 'yes' or 'no')
print 'texture_compression_s3tc:\t%s' % (self.vertexcache.texcache.s3tc and 'yes' or 'no')
print 'bgra:\t\t\t\t%s' % (self.vertexcache.texcache.bgra and 'yes' or 'no')
print 'shaders:\t\t\t%s' % (self.glstate.shaders and 'yes' or 'no')
print 'gpu_shader4:\t\t\t%s' % (glInitGpuShader4EXT() and 'yes' or 'no')
print 'instanced_arrays:\t\t%s' % (self.glstate.instanced_arrays and 'yes' or 'no')
print 'multi_draw_arrays:\t\t%s' % (self.glstate.multi_draw_arrays and 'yes' or 'no')
def OnEraseBackground(self, event):
# Prevent flicker when resizing / painting on MSW
#if __debug__: print "OnEraseBackground"
self.needclear=True # ATI drivers require clear afer resize
def OnKeyDown(self, event):
if self.clickmode:
event.Skip()
else:
# Manually propagate
self.frame.OnKeyDown(event)
def OnMouseWheel(self, event):
# under wxMac 2.8 scroll events don't arrive in the main frame, so catch here and forward
if self.clickmode:
event.Skip()
else:
# Manually propagate
self.frame.OnMouseWheel(event)
def OnTimer(self, event):
# mouse scroll - fake up a key event and pass it up
size=self.GetClientSize()
posx=self.mousenow[0]
posy=self.mousenow[1]
keyevent=wx.KeyEvent()
keyevent.m_controlDown=wx.GetKeyState(wx.WXK_CONTROL)
keyevent.m_shiftDown=wx.GetKeyState(wx.WXK_SHIFT)
if posx<sband:
keyevent.m_keyCode=wx.WXK_LEFT
elif posy<sband:
keyevent.m_keyCode=wx.WXK_UP
elif size.x-posx<sband:
keyevent.m_keyCode=wx.WXK_RIGHT
elif size.y-posy<sband:
keyevent.m_keyCode=wx.WXK_DOWN
if keyevent.m_keyCode:
self.frame.OnKeyDown(keyevent)
def OnLeftDown(self, event):
if self.clickmode==ClickModes.Move: return
#event.Skip(False) # don't change focus
self.mousenow=self.clickpos=[event.GetX(),event.GetY()]
self.clickctrl=event.CmdDown()
self.frame.canvas.SetFocus() # otherwise focus goes to None under wxGTK
self.CaptureMouse()
size = self.GetClientSize()
if event.GetX()<sband or event.GetY()<sband or size.x-event.GetX()<sband or size.y-event.GetY()<sband:
# mouse scroll
self.clickmode=ClickModes.Scroll
self.timer.Start(50)
else:
self.clickmode=ClickModes.Undecided
self.select()
self.draginert=True # was (self.clickmode!=ClickModes.DragNode)
def OnLeftUp(self, event):
#print "up", ClickModes.DragNode
if self.HasCapture(): self.ReleaseMouse()
self.timer.Stop()
if self.clickmode==ClickModes.DragNode:
assert len(self.selected)==1
if self.selectedlayoutpending:
if __debug__: clock2 = time.clock()
placement = list(self.selected)[0]
self.selectednode = placement.layout(self.tile, self.selectednode)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
self.selectedlayoutpending = False
self.Refresh()
if self.snapnode:
# split segment at snapped-to node
(poly,idx) = self.snapnode
if idx!=0 and idx!=len(poly.nodes[0])-1:
poly2 = poly.clone()
poly2.load(self.lookup, self.defs, self.vertexcache)
placements = self.placements[self.tile]
self.undostack.append(UndoEntry(self.tile, UndoEntry.SPLIT, [(placements.index(poly), poly.clone()),
(len(placements), poly2)]))
placements.append(poly2)
poly.nodes[0] = poly.nodes[0][:idx+1]
poly.layout(self.tile, recalc=True)
poly2.nodes[0]= poly2.nodes[0][idx:]
poly2.layout(self.tile, recalc=True)
self.selected = set([poly,poly2])
self.selectednode = self.selectedhandle = None
self.Refresh()
self.snapnode = None
elif self.clickmode==ClickModes.Drag:
for placement in self.selected:
placement.layout(self.tile)
elif self.clickmode==ClickModes.DragBox:
self.Refresh() # get rid of drag box
self.clickmode=None
self.frame.ShowSel()
event.Skip()
def OnMiddleDown(self, event):
if self.clickmode: return
self.clickmode=ClickModes.Move
self.mousenow=self.clickpos=[event.GetX(),event.GetY()]
self.CaptureMouse()
self.SetCursor(self.movecursor)
def OnMiddleUp(self, event):
if self.HasCapture(): self.ReleaseMouse()
self.SetCursor(wx.NullCursor)
self.clickmode=None
event.Skip()
def OnIdle(self, event):
if self.valid: # can get Idles during reload under X
if self.clickmode==ClickModes.DragNode:
assert len(self.selected)==1
if self.selectedlayoutpending:
if __debug__: clock2 = time.clock()
placement = list(self.selected)[0]
self.selectednode = placement.layout(self.tile, self.selectednode)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
assert self.selectednode
self.selectedlayoutpending = False
self.Refresh()
elif self.needrefresh:
# Mouse motion with a selected polygon draws to the back buffer, which Mac uses as backing store. So refresh.
self.Refresh()
def OnMouseMotion(self, event):
# Capture unreliable on Mac, so may have missed Up events. See
# https://sourceforge.net/tracker/?func=detail&atid=109863&aid=1489131&group_id=9863
#self.getworldloc(event.GetX(),event.GetY()) # debug
assert self.valid
if not self.valid: return
if self.clickmode==ClickModes.Move:
if not event.MiddleIsDown():
self.OnMiddleUp(event)
return
elif self.clickmode and not event.LeftIsDown():
self.OnLeftUp(event)
return
if self.timer.IsRunning():
# Continue mouse scroll
self.mousenow=[event.GetX(),event.GetY()] # not known in timer
return
if not self.clickmode:
size = self.GetClientSize()
# Change cursor if over a window border
if event.GetX()<sband or event.GetY()<sband or size.x-event.GetX()<sband or size.y-event.GetY()<sband:
self.SetCursor(self.scrollcursor)
return
# Change cursor if over a node
if len(self.selected)==1 and isinstance(list(self.selected)[0], Polygon):
if list(self.selected)[0].pick_nodes(self.glstate.pickmatrix(event.GetX(), size[1]-1-event.GetY(), 5,5, *size), True):
self.SetCursor(self.dragcursor) # hovering over node
return
self.SetCursor(wx.NullCursor)
return
assert (self.clickmode!=ClickModes.Undecided)
if self.clickmode==ClickModes.Move:
(oldlat,oldlon)=self.getworldloc(*self.mousenow)
self.mousenow=[event.GetX(),event.GetY()]
(lat,lon)=self.getworldloc(*self.mousenow)
self.frame.loc=(self.frame.loc[0]-lat+oldlat, self.frame.loc[1]-lon+oldlon)
self.goto(self.frame.loc)
self.frame.ShowLoc()
return
if self.draginert and abs(event.GetX()-self.clickpos[0])<self.dragx and abs(event.GetY()-self.clickpos[1])<self.dragx:
return
else:
self.draginert=False
if self.clickmode==ClickModes.DragNode:
# Start/continue node drag
self.SetCursor(self.dragcursor)
self.snapnode = None
poly=list(self.selected)[0]
if isinstance(poly, Network) and not self.selectedhandle and self.selectednode[1] in [0,len(poly.nodes[0])-1]:
# snap end nodes to nodes in other network segments
size = self.GetClientSize()
proj = self.glstate.pickmatrix(event.GetX(), size[1]-1-event.GetY(), 13,13, *size)
for p in self.placements[self.tile]:
if isinstance(p, Network) and p!=poly:
hit = p.pick_nodes(proj, False)
if hit:
self.snapnode = (p, hit[0][1])
break
if self.snapnode:
node = self.snapnode[0].nodes[0][self.snapnode[1]]
(lon,lat) = (node.lon,node.lat) # snap to matching network node location
else:
(lat,lon)=self.getworldloc(event.GetX(), event.GetY())
lat=max(self.tile[0], min(self.tile[0]+1, lat))
lon=max(self.tile[1], min(self.tile[1]+1, lon))
if not self.frame.bkgd: # No undo for background image
newundo=UndoEntry(self.tile, UndoEntry.MOVE, [(self.placements[self.tile].index(poly), poly.clone())])
if not (self.undostack and self.undostack[-1].equals(newundo)):
self.undostack.append(newundo)
self.frame.toolbar.EnableTool(wx.ID_SAVE, True)
self.frame.toolbar.EnableTool(wx.ID_UNDO, True)
if self.frame.menubar:
self.frame.menubar.Enable(wx.ID_SAVE, True)
self.frame.menubar.Enable(wx.ID_UNDO, True)
if self.selectedhandle:
poly.updatehandle(self.selectednode, self.selectedhandle, event.CmdDown(), lat, lon, self.tile)
else:
poly.updatenode(self.selectednode, lat, lon, self.tile)
self.selectedlayoutpending = True # need to do full layout at some point
self.Refresh() # show updated node
self.frame.ShowSel()
return
elif self.clickmode==ClickModes.Drag:
# Continue move drag
(lat,lon)=self.getworldloc(event.GetX(), event.GetY())
if (lat>self.tile[0] and lat<self.tile[0]+1 and
lon>self.tile[1] and lon<self.tile[1]+1):
(oldlat,oldlon)=self.getworldloc(*self.mousenow)
self.movesel(lat-oldlat, lon-oldlon)
if not self.frame.bkgd: # No undo for background image
self.frame.toolbar.EnableTool(wx.ID_SAVE, True)
self.frame.toolbar.EnableTool(wx.ID_UNDO, True)
if self.frame.menubar:
self.frame.menubar.Enable(wx.ID_SAVE, True)
self.frame.menubar.Enable(wx.ID_UNDO, True)
elif self.clickmode==ClickModes.DragBox:
self.select()
self.mousenow=[event.GetX(),event.GetY()] # not known in paint
def OnPaint(self, event):
if event: wx.PaintDC(self) # Tell the window system that we're on the case
if not self.doneinit:
self.glInit()
self.needrefresh=False
size = self.GetClientSize()
#print "pt", size
if size.width<=0: return # may be junk on startup
if wx.VERSION >= (2,9):
self.SetCurrent(self.context)
else:
self.SetCurrent()
if log_paint:
clock=clock2=time.clock()
glViewport(0, 0, *size)
vd=self.d*size.y/size.x
proj=array([[1.0/self.d,0,0,0], [0,1.0/vd,0,0], [0,0,(-1.0/30)/vd,0], [0,0,0,1]], float64) # glOrtho(-self.d, self.d, -vd, vd, -30*vd, 30*vd) # 30 ~= 1/sin(2), where 2 is minimal elevation angle
proj=dot(array([[1,0,0,0], [0,cos(radians(self.e)),sin(radians(self.e)),0], [0,-sin(radians(self.e)),cos(radians(self.e)),0], [0,0,0,1]], float64), proj) # glRotatef(self.e, 1.0,0.0,0.0)
proj=dot(array([[cos(radians(self.h)),0,-sin(radians(self.h)),0], [0,1,0,0], [sin(radians(self.h)),0,cos(radians(self.h)),0], [0,0,0,1]], float64), proj) # glRotatef(self.h, 0.0,1.0,0.0)
self.glstate.proj = dot(array([[1,0,0,0], [0,1,0,0], [0,0,1,0], [-self.x,-self.y,-self.z,1]], float64), proj) # glTranslatef(-self.x, -self.y, -self.z)
glLoadMatrixd(self.glstate.proj)
# Workaround for buggy ATI drivers: Check that occlusion queries actually work
if self.glstate.occlusion_query is None:
if not bool(glGenQueries):
if log_glstate: print 'occlusion_query:\t\tno'
self.glstate.occlusion_query=False
else:
self.glstate.occlusion_query=hasGLExtension('GL_ARB_occlusion_query2') and GL_ANY_SAMPLES_PASSED or GL_SAMPLES_PASSED
if self.glstate.occlusion_query:
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
self.glstate.set_texture(self.vertexcache.texcache.get(fallbacktexture)) # ATI drivers don't like 0
self.glstate.set_color(COL_WHITE) # Ensure colour indexing off
self.glstate.set_depthtest(False) # Draw even if occluded
self.glstate.set_poly(True) # Disable writing to depth buffer
self.glstate.set_cull(False)
self.glstate.alloc_queries(1)
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE)
glBeginQuery(self.glstate.occlusion_query, self.glstate.queries[0])
glBegin(GL_QUADS)
glVertex3f( 100, 0, -100)
glVertex3f( 100, 0, 100)
glVertex3f(-100, 0, 100)
glVertex3f(-100, 0, -100)
glEnd()
glEndQuery(self.glstate.occlusion_query)
if not glGetQueryObjectuiv(self.glstate.queries[0], GL_QUERY_RESULT):
self.glstate.occlusion_query=False
if log_glstate: print 'occlusion_query:\t\tbroken'
else:
if log_glstate: print 'occlusion_query:\t\tyes (%s)' % (hasGLExtension('GL_ARB_occlusion_query2') and 'GL_ANY_SAMPLES_PASSED' or 'GL_SAMPLES_PASSED')
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE)
# Ground terrain
if not self.valid:
# Sea
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
self.glstate.set_color((0.25, 0.25, 0.50))
if self.glstate.shaders:
self.glstate.set_texture(None) # ATI drivers don't like 0
else:
self.glstate.set_texture(0)
glBegin(GL_QUADS)
glVertex3f( onedeg*cos(radians(1+self.tile[0]))/2, 0, -onedeg/2)
glVertex3f( onedeg*cos(radians(self.tile[0]))/2, 0, onedeg/2)
glVertex3f(-onedeg*cos(radians(self.tile[0]))/2, 0, onedeg/2)
glVertex3f(-onedeg*cos(radians(1+self.tile[0]))/2, 0, -onedeg/2)
glEnd()
self.SwapBuffers()
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
self.needclear=False
self.frame.canvas.SetFocus() # under wxGTK need to manually set focus on startup
return
elif self.needclear:
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
self.needclear=False
# Map imagery & background
has_imagery = self.imagery.placements(self.d, size) # allocate into dynamic VBO
if log_paint:
print "%6.3f time to get imagery" % (time.clock()-clock2)
clock2=time.clock()
if self.background and self.background.islaidout():
has_imagery = True
if self.frame.bkgd:
self.selected=set([self.background]) # Override selection while dialog is open
elif self.background in self.selected:
self.selected=set()
elif self.frame.bkgd:
self.selected=set()
# Mesh and Nets
self.glstate.set_instance(self.vertexcache)
self.glstate.set_color(COL_UNPAINTED)
self.glstate.set_cull(True)
self.glstate.set_poly(False)
if __debug__:
elev = self.vertexcache.getElevationMesh(self.tile)
if debugapt: glPolygonMode(GL_FRONT, GL_LINE)
if debugapt and hasattr(elev, 'divwidth'):
# show elevation mesh buckets
self.glstate.set_depthtest(False)
self.glstate.set_texture(None)
self.glstate.set_color(COL_DRAGBOX)
glBegin(GL_LINES)
for i in range(-ElevationMesh.DIVISIONS/2, ElevationMesh.DIVISIONS/2+1):
glVertex3f( (ElevationMesh.DIVISIONS/2) * elev.divwidth, 0, i * elev.divheight)
glVertex3f(-(ElevationMesh.DIVISIONS/2) * elev.divwidth, 0, i * elev.divheight)
for j in range(-ElevationMesh.DIVISIONS/2, ElevationMesh.DIVISIONS/2+1):
glVertex3f(j * elev.divwidth, 0, (ElevationMesh.DIVISIONS/2) * elev.divheight)
glVertex3f(j * elev.divwidth, 0, -(ElevationMesh.DIVISIONS/2) * elev.divheight)
glEnd()
self.glstate.set_color(COL_SELECTED)
glBegin(GL_LINE_LOOP)
glVertex3f((self.ej-ElevationMesh.DIVISIONS/2) *elev.divwidth, 0, (ElevationMesh.DIVISIONS/2 -self.ei)*elev.divheight)
glVertex3f((self.ej-ElevationMesh.DIVISIONS/2+1)*elev.divwidth, 0, (ElevationMesh.DIVISIONS/2 -self.ei)*elev.divheight)
glVertex3f((self.ej-ElevationMesh.DIVISIONS/2+1)*elev.divwidth, 0, (ElevationMesh.DIVISIONS/2-1-self.ei)*elev.divheight)
glVertex3f((self.ej-ElevationMesh.DIVISIONS/2) *elev.divwidth, 0, (ElevationMesh.DIVISIONS/2-1-self.ei)*elev.divheight)
glEnd()
self.glstate.set_color(COL_UNPAINTED)
glBegin(GL_TRIANGLES)
print (self.ei,self.ej), len(elev.buckets[self.ei][self.ej]), 'tris'
for tri in elev.tris[elev.buckets[self.ei][self.ej]]:
glVertex3fv(tri['p1'])
glVertex3fv(tri['p2'])
glVertex3fv(tri['p3'])
glEnd()
self.glstate.set_depthtest(True)
self.glstate.set_texture(0) # texture shader
if self.glstate.shaders:
if not prefs.options&Prefs.ELEVATION:
glUniform4f(self.glstate.transform_pos, 0, -1, 0, 0) # Defeat elevation data
else:
glUniform4f(self.glstate.transform_pos, *zeros(4,float32))
else:
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
if not self.options&Prefs.ELEVATION:
glScalef(1,0,1) # Defeat elevation data:
(mesh, netindices) = self.vertexcache.getMesh(self.tile)
for (base,number,texno) in mesh:
self.glstate.set_texture(texno)
glDrawArrays(GL_TRIANGLES, base, number)
if not self.options&Prefs.ELEVATION:
if self.glstate.shaders:
glUniform4f(self.glstate.transform_pos, *zeros(4,float32))
else:
glLoadIdentity()
if __debug__:
if debugapt: glPolygonMode(GL_FRONT, GL_FILL)
if netindices is not None:
(base, count) = netindices
self.glstate.set_vector(self.vertexcache)
self.glstate.set_texture(None)
self.glstate.set_color(None)
self.glstate.set_depthtest(False) # Need line to appear over terrain
glDrawElements(GL_LINES, count, GL_UNSIGNED_INT, self.glstate.vector_indices_vbo + base*4)
if log_paint:
print "%6.3f time to draw mesh" % (time.clock()-clock2)
clock2=time.clock()
# Objects and Polygons
placements=self.placements[self.tile]
navaidplacements=self.navaidplacements[self.tile]
self.glstate.set_dynamic(self.vertexcache) # realize
# Draw clutter with dynamic geometry
self.vertexcache.buckets.draw(self.glstate, self.frame.bkgd and set() or self.selected, self.aptdata, has_imagery, prefs.imageryopacity) # background image is always drawn with its own opacity setting
if log_paint:
print "%6.3f time to draw dynamic" % (time.clock()-clock2)
clock2=time.clock()
# Draw clutter with static geometry (ignoring layer ordering since it doesn't really matter so much for Objects)
self.glstate.set_instance(self.vertexcache)
self.glstate.set_poly(False)
self.glstate.set_depthtest(True)
if self.glstate.instanced_arrays:
self.glstate.set_color(COL_UNPAINTED)
self.glstate.set_texture(0) # has side-effect so shader program won't be reset
glUseProgram(self.glstate.instancedshader)
glEnableVertexAttribArray(self.glstate.instanced_transform_pos)
glVertexAttribDivisorARB(self.glstate.instanced_transform_pos, 1)
assert type(self.selected)==set
selected = self.selected.copy()
if selected:
glEnableVertexAttribArray(self.glstate.instanced_selected_pos)
glVertexAttribDivisorARB(self.glstate.instanced_selected_pos, 1)
for o in self.selected: selected.update(o.placements) # include children
else:
glVertexAttrib1f(self.glstate.instanced_selected_pos, 0)
for objdef in self.defs.values(): # benefit of sorting by texture would be marginal
objdef.draw_instanced(self.glstate, selected)
glDisableVertexAttribArray(self.glstate.instanced_transform_pos)
glDisableVertexAttribArray(self.glstate.instanced_selected_pos)
else:
# Instancing not supported
self.glstate.set_texture(0) # load texture shader
selected = self.selected.copy()
if selected:
for o in self.selected: selected.update(o.placements) # include children
for objdef in self.defs.values(): # benefit of sorting by texture would be marginal
objdef.draw_instanced(self.glstate, selected)
if self.glstate.shaders:
glUniform4f(self.glstate.transform_pos, *zeros(4,float32)) # drawing Objects alters the matrix
else:
glLoadIdentity() # Drawing Objects alters the matrix
glMatrixMode(GL_PROJECTION)
if log_paint:
print "%6.3f time to draw static" % (time.clock()-clock2)
clock2=time.clock()
# Overlays
self.glstate.set_texture(None) # resets shader
self.glstate.set_depthtest(False)
self.glstate.set_poly(True)
# Selected nodes - very last so overwrites everything
if len(self.selected)==1:
# don't bother setting VBO since this is done immediate
list(self.selected)[0].draw_nodes(self.glstate, self.selectednode)
# labels
if self.codeslist and self.d>2000: # arbitrary
#if __debug__: print "labels"
glCallList(self.codeslist)
# Position centre
#if __debug__: print "cursor"
self.glstate.set_color(COL_CURSOR)
glTranslatef(self.x, self.y, self.z)
glBegin(GL_LINES)
glVertex3f(-0.5,0,0)
glVertex3f( 0.5,0,0)
glVertex3f(0,0,-0.5)
glVertex3f(0,0, 0.5)
glVertex3f(0,0,-0.5)
glVertex3f(0.125,0,-0.375)
glVertex3f(0,0,-0.5)
glVertex3f(-0.125,0,-0.375)
glEnd()
# 2D stuff
if self.clickmode==ClickModes.DragBox or self.imagery.provider_logo:
glLoadIdentity()
# drag box
if self.clickmode==ClickModes.DragBox:
if __debug__: print "drag"
self.glstate.set_color(COL_DRAGBOX)
x0=float(self.clickpos[0]*2)/size.x-1
y0=1-float(self.clickpos[1]*2)/size.y
x1=float(self.mousenow[0]*2)/size.x-1
y1=1-float(self.mousenow[1]*2)/size.y
glBegin(GL_LINE_LOOP)
glVertex3f(x0, y0, -0.9)
glVertex3f(x0, y1, -0.9)
glVertex3f(x1, y1, -0.9)
glVertex3f(x1, y0, -0.9)
glEnd()
# imagery attribution
if self.imagery.provider_logo:
(filename,width,height)=self.imagery.provider_logo
self.glstate.set_color(COL_UNPAINTED)
self.glstate.set_texture(self.vertexcache.texcache.get(filename,wrap=False,fixsize=True))
glBegin(GL_QUADS)
glTexCoord2f(0,0)
glVertex3f(-1,-1, -0.9)
glTexCoord2f(0,1)
glVertex3f(-1,-1+height*2.0/size.y, -0.9)
glTexCoord2f(1,1)
glVertex3f(-1+width*2.0/size.x,-1+height*2.0/size.y, -0.9)
glTexCoord2f(1,0)
glVertex3f(-1+width*2.0/size.x,-1, -0.9)
glEnd()
glLoadMatrixd(self.glstate.proj) # Restore state for unproject
self.glstate.set_poly(False)
if log_paint: print "%6.3f time in OnPaint" % (time.clock()-clock)
# Display
self.SwapBuffers()
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
self.needclear=False
def select(self):
if __debug__: print "sel"
#if not self.currentobjects():
# self.selections=[] # Can't remember
if __debug__: clock=time.clock()
size = self.GetClientSize()
if self.clickmode==ClickModes.DragBox:
proj = self.glstate.pickmatrix((self.clickpos[0]+self.mousenow[0])/2, size[1]-1-(self.clickpos[1]+self.mousenow[1])/2,
abs(self.clickpos[0]-self.mousenow[0]), abs(self.clickpos[1]-self.mousenow[1]), *size)
else: # at point
proj = self.glstate.pickmatrix(self.clickpos[0], size[1]-1-self.clickpos[1], 5,5, *size)
if self.frame.bkgd: # Don't allow selection of other objects while background dialog is open
if self.background and self.background.islaidout():
placements=[self.background]
else:
placements=[]
else:
placements=self.placements[self.tile]
# Select poly node?
if (self.clickmode==ClickModes.Undecided and len(self.selected)==1 and isinstance(list(self.selected)[0], Polygon)):
selected = list(self.selected)[0].pick_nodes(proj, True)
if selected:
# No need to look further if user has clicked on a node or handle within selected polygon
(self.selectednode, self.selectedhandle) = selected
self.clickmode = ClickModes.DragNode
self.selectedlayoutpending = False
if __debug__: print "%6.3f time in select" %(time.clock()-clock)
self.frame.ShowSel()
return
self.selectednode = self.selectedhandle = None
# Select placements
glLoadMatrixd(proj)
self.glstate.set_texture(self.vertexcache.texcache.get(fallbacktexture)) # textured shader throughout. ATI drivers don't like 0
self.glstate.set_color(COL_WHITE) # Ensure colour indexing off
self.glstate.set_depthtest(False) # Make selectable even if occluded
self.glstate.set_poly(True) # Disable writing to depth buffer
self.glstate.set_cull(False) # Enable selection of "invisible" faces
selections = set()
lookup = []
objdefs = (not self.locked&Locked.OBJ) and [objdef for objdef in self.defs.values() if isinstance(objdef,ObjectDef)] or []
if self.glstate.occlusion_query:
needed = sum([len(objdef.instances) for objdef in objdefs]) + len(placements) # upper limit
self.glstate.alloc_queries(needed)
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE) # Don't want to update frame buffer either
else:
glSelectBuffer(len(placements)*8) # Twice as many for two-phase drawing
glRenderMode(GL_SELECT)
glInitNames()
glPushName(0)
self.glstate.set_instance(self.vertexcache)
if not self.glstate.shaders:
glMatrixMode(GL_MODELVIEW)
for objdef in objdefs:
objdef.pick_instanced(self.glstate, proj, selections, lookup)
if self.glstate.shaders:
glUniform4f(self.glstate.transform_pos, *zeros(4,float32)) # drawing Objects alters the matrix
else:
glLoadIdentity() # Drawing Objects alters the matrix
glMatrixMode(GL_PROJECTION)
if __debug__: print "%6.3f time to issue instance" %(time.clock()-clock)
self.glstate.set_dynamic(self.vertexcache)
for p in placements:
if not p.definition.type & self.locked:
p.pick_dynamic(self.glstate, lookup)
if __debug__: print "%6.3f time to issue dynamic" %(time.clock()-clock)
# Now check for selections
if self.glstate.occlusion_query:
for k in range(len(lookup)):
if glGetQueryObjectuiv(self.glstate.queries[k], GL_QUERY_RESULT):
selections.add(lookup[k])
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE)
else:
try:
for min_depth, max_depth, (name,) in glRenderMode(GL_RENDER):
selections.add(lookup[int(name)])
except: # overflow
if __debug__: print_exc()
if __debug__: print "%6.3f time to check queries" %(time.clock()-clock)
# promote children and filter out navaids
selections = set([placement.parent or placement for placement in selections]).difference(self.navaidplacements[self.tile])
if self.frame.bkgd: # Don't allow selection of other objects while background dialog is open
if self.clickmode==ClickModes.Drag or self.background in selections:
self.clickmode=ClickModes.Drag
else:
self.clickmode=ClickModes.DragBox # Can't leave as ClickModes.Undecided
self.Refresh()
self.frame.ShowSel()
return
if self.clickmode==ClickModes.DragBox: # drag box - add or remove all selections
if self.clickctrl:
self.selected=self.selectsaved.copy() # reset each time
for i in selections:
if i in self.selected:
self.selected.remove(i)
else:
self.selected.add(i)
else:
self.selected=selections.copy()
else: # click - Add or remove one
if not selections:
# Start drag box
self.clickmode=ClickModes.DragBox
self.selectsaved=self.selected
else:
self.clickmode=ClickModes.Drag
if self.clickctrl:
for i in selections:
if i not in self.selected:
self.selected.add(i)
break
else: # all selected - remove one
for i in self.selected:
if i in selections:
self.selected.remove(i)
break
else:
if not selections:
self.selected=set()
elif selections==self.selections and len(self.selected)==1 and list(self.selected)[0] in self.selections:
# cycle through selections by improvising an ordering on the set
ordered=list(selections)
idx=ordered.index(list(self.selected)[0])
self.selected=set([ordered[(idx+1)%len(ordered)]])
else:
self.selected=set(list(selections)[:1])
self.selections=selections
if __debug__: print "%6.3f time in select" %(time.clock()-clock)
self.Refresh()
self.frame.ShowSel()
def latlon2m(self, lat, lon):
return(((lon-self.centre[1])*onedeg*cos(radians(lat)),
(self.centre[0]-lat)*onedeg))
# create the background polygon. Defer layout to goto since can be called in reload() before location is known.
def setbackground(self, prefs, loc=None, newfile=None, layoutnow=False):
if newfile is None and prefs.package in prefs.packageprops:
backgroundfile=prefs.packageprops[prefs.package][0]
else:
backgroundfile=newfile # may be '' if just cleared
if not backgroundfile:
if self.background: self.background.clearlayout()
self.background=None
prefs.packageprops.pop(prefs.package,False)
return
elif not self.background or self.background.name!=backgroundfile:
if backgroundfile[0]==curdir:
backgroundfile = join(glob(join(prefs.xplane,gcustom,prefs.package))[0], backgroundfile[2:])
try:
texture = self.vertexcache.texcache.get(backgroundfile, wrap=False, downsample=False, fixsize=True)
except:
if __debug__: print_exc()
texture=self.vertexcache.texcache.get(fallbacktexture)
if not self.background:
if prefs.package in prefs.packageprops:
p=prefs.packageprops[prefs.package][1:]
if len(p)==6:
# convert from pre 2.15 setting
(lat, lon, hdg, width, length, opacity)=p
x=width/(2*onedeg*cos(radians(lat)))
z=length/(2*onedeg)
l=hypot(x,z)
nodes=[(lon-x,lat-z),(lon+x,lat-z),(lon+x,lat+z),(lon-x,lat+z)]
if hdg:
for j in range(len(nodes)):
h=atan2(nodes[j][0]-lon, nodes[j][1]-lat)+radians(hdg)
l=hypot(nodes[j][0]-lon, nodes[j][1]-lat)
nodes[j] = Node([lon+sin(h)*l, lat+cos(h)*l])
else:
nodes = [Node([p[i], p[i+1]]) for i in range(0, len(p), 2)]
self.background=DrapedImage('*background', 65535, [nodes])
else: # new
try: # georeferenced
from osgeo import osr, gdal
ds = gdal.Open(backgroundfile.encode('utf8')) # Needs to be utf8 for old versions on Linux!
gt = ds.GetGeoTransform()
width, height = ds.RasterXSize, ds.RasterYSize
old_cs= osr.SpatialReference()
old_cs.ImportFromWkt(ds.GetProjectionRef())
new_cs = osr.SpatialReference()
new_cs.SetWellKnownGeogCS('WGS84')
tr = osr.CoordinateTransformation(old_cs,new_cs)
nodes = [Node(tr.TransformPoint(gt[0], gt[3] + width*gt[4] + height*gt[5])),
Node(tr.TransformPoint(gt[0] + width*gt[1] + height*gt[2], gt[3] + width*gt[4] + height*gt[5])),
Node(tr.TransformPoint(gt[0] + width*gt[1] + height*gt[2], gt[3] )),
Node(tr.TransformPoint(gt[0], gt[3] ))]
self.background=DrapedImage('*background', 65535, [nodes])
except:
if __debug__: print_exc()
self.background=DrapedImage('*background', 65535, loc[0], loc[1], self.d, self.h)
self.background.load(self.lookup, self.defs, self.vertexcache)
self.background.definition.layer = ClutterDef.IMAGEFILELAYER
self.background.singlewinding = self.background.fixednodes = True
self.background.canbezier = False
for i in range(len(self.background.nodes[0])):
self.background.nodes[0][i].rest = [(i+1)/2%2,i/2] # assign UVs
if self.background.name!=backgroundfile:
self.background.name=backgroundfile
self.background.definition.texture = texture
self.background.flush() # force layout with new texture
if layoutnow:
self.background.layout(self.tile)
def add(self, name, lat, lon, hdg, size):
# Add new clutter
if not name:
return False
texerr=None
ext = splitext(name)[1].lower()
try:
if not ext and not name.startswith(PolygonDef.EXCLUDE):
raise # probably a space in a library export statement
elif ext in [ObjectDef.OBJECT, AutoGenPointDef.AGP]:
placement = Object.factory(name, lat, lon, hdg)
else:
placement = Polygon.factory(name, None, lat, lon, size, hdg)
except UnicodeError:
if __debug__: print_exc()
myMessageBox('Filename "%s" uses non-ASCII characters' % name, 'Cannot add this object.', wx.ICON_ERROR|wx.OK, self.frame)
return False
except:
if __debug__: print_exc()
myMessageBox("Can't read " + name, 'Cannot add this object.', wx.ICON_ERROR|wx.OK, self.frame)
return False
if __debug__: print "add", placement
if not placement.load(self.lookup, self.defs, self.vertexcache):
myMessageBox("Can't read " + name, 'Cannot add this object.', wx.ICON_ERROR|wx.OK, self.frame)
return False
texerr=placement.definition.texerr
placement.definition.texerr=None # Don't report again
# Hack! Can only decide nature of new draped polygon once we've loaded its definition
if isinstance(placement, Draped):
if placement.definition.ortho:
placement.param = 65535
placement.singlewinding = placement.fixednodes = True
placement.canbezier = False
for i in range(4):
placement.nodes[0][i].rest = [(i+1)/2%2, i/2] # ST coords
else:
placement.canbezier = True
placement.layout(self.tile)
placements=self.placements[self.tile]
self.undostack.append(UndoEntry(self.tile, UndoEntry.ADD, [(len(placements), placement)]))
placements.append(placement)
self.selected=set([placement])
self.selectednode=None
self.Refresh()
self.frame.ShowSel()
if texerr:
myMessageBox(u"%s: %s" % texerr, "Can't read texture.", wx.ICON_INFORMATION|wx.OK, self.frame)
return True
def addnode(self, name, lat, lon, hdg, size):
# Add new node/winding
if len(self.selected)!=1 or not isinstance(list(self.selected)[0], Polygon) or self.frame.bkgd: # No additional nodes for background image
return False
placement=list(self.selected)[0]
newundo=UndoEntry(self.tile, UndoEntry.MODIFY, [(self.placements[self.tile].index(placement), placement.clone())])
if self.selectednode:
newnode=placement.addnode(self.tile, self.selectednode, lat, lon)
else:
newnode=placement.addwinding(self.tile, size, hdg)
if not newnode:
return False
self.undostack.append(newundo)
if not self.selectednode:
self.selected=set([placement])
self.selectednode=newnode
self.Refresh()
self.frame.ShowSel()
return True
def togglebezier(self):
# Add new node/winding
if len(self.selected)!=1 or not self.selectednode: return False
placement = list(self.selected)[0]
newundo = UndoEntry(self.tile, UndoEntry.MODIFY, [(self.placements[self.tile].index(placement), placement.clone())])
newnode = placement.togglebezier(self.tile, self.selectednode)
if not newnode:
return False
else:
self.selectednode = newnode
if not (self.undostack and self.undostack[-1].equals(newundo)):
self.undostack.append(newundo)
self.Refresh()
self.frame.ShowSel()
return True
def movesel(self, dlat, dlon, dhdg=0, dparam=0, loc=None):
# returns True if changed something
if not self.selected: return False
if self.selectednode:
placement=list(self.selected)[0]
if not self.frame.bkgd: # No undo for background image
newundo=UndoEntry(self.tile, UndoEntry.MOVE, [(self.placements[self.tile].index(placement), placement.clone())])
if not (self.undostack and self.undostack[-1].equals(newundo)):
self.undostack.append(newundo)
if __debug__: clock2 = time.clock()
self.selectednode=placement.movenode(self.selectednode, dlat, dlon, dparam, self.tile, False)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
assert self.selectednode
else:
moved=[]
placements=self.placements[self.tile]
for placement in self.selected:
if not self.frame.bkgd: # No undo for background image
moved.append((placements.index(placement), placement.clone()))
if __debug__: clock2 = time.clock()
placement.move(dlat, dlon, dhdg, dparam, loc, self.tile)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
if moved:
newundo=UndoEntry(self.tile, UndoEntry.MOVE, moved)
if not (self.undostack and self.undostack[-1].equals(newundo)):
self.undostack.append(newundo)
self.Refresh()
self.frame.ShowSel()
return True
def delsel(self, shift):
# returns True if deleted something
if not self.selected:
return False
elif self.frame.bkgd:
if self.selectednode:
return False
else:
self.frame.bkgd.OnClear(None) # Yuck!
elif self.selectednode:
# Delete node/winding
placement=list(self.selected)[0]
newundo=UndoEntry(self.tile, UndoEntry.MODIFY, [(self.placements[self.tile].index(placement), placement.clone())])
if shift:
newnode=placement.delwinding(self.tile, self.selectednode)
else:
newnode=placement.delnode(self.tile, self.selectednode)
if newnode:
self.undostack.append(newundo)
self.selectednode=newnode
assert self.selectednode
else:
deleted=[]
placements=self.placements[self.tile]
for placement in self.selected:
placement.clearlayout() # no point taking up space in vbo
i=placements.index(placement)
deleted.insert(0, (i, placement)) # LIFO
placements.pop(i)
self.undostack.append(UndoEntry(self.tile, UndoEntry.DEL, deleted))
self.selected=set()
self.Refresh()
self.frame.ShowSel()
return True
def copysel(self):
if self.selectednode or not self.selected: return None # can't copy and paste nodes
self.clipboard = set()
avlat = sum([placement.location()[0] for placement in self.selected]) / len(self.selected)
avlon = sum([placement.location()[1] for placement in self.selected]) / len(self.selected)
for placement in self.selected:
# Centre copied objects relative to average location
self.clipboard.add(placement.copy(avlat, avlon))
return (avlat,avlon)
def paste(self, lat, lon):
if not self.clipboard: return None
newplacements = []
for placement in self.clipboard:
clone = placement.clone()
clone.load(self.lookup, self.defs, self.vertexcache, True)
clone.move(lat, lon, 0, 0, None, self.tile)
newplacements.append(clone)
placements = self.placements[self.tile]
self.undostack.append(UndoEntry(self.tile, UndoEntry.ADD, [(len(placements), placement) for placement in newplacements]))
placements.extend(newplacements)
self.selected = set(newplacements)
self.selectednode = None
self.Refresh()
self.frame.ShowSel()
return (lat,lon)
def importregion(self, dsfdirs, netdefs):
if len(self.selected)!=1 or not isinstance(list(self.selected)[0], Exclude):
return False
exc = list(self.selected)[0]
bbox = BBox()
for node in exc.nodes[0]:
bbox.include(node.lon, node.lat)
dsfs = []
for path in dsfdirs:
if not glob(path): continue
pathlen=len(glob(path)[0])+1
thisdsfs=glob(join(path, '*', gnavdata, "%+02d0%+03d0" % (int(self.tile[0]/10), int(self.tile[1]/10)), "%+03d%+04d.[dD][sS][fF]" % (self.tile[0], self.tile[1])))
# asciibetical, except global is last
thisdsfs.sort(lambda x,y: ((x[pathlen:].lower().startswith('-global ') and 1) or
(y[pathlen:].lower().startswith('-global ') and -1) or
cmp(x,y)))
dsfs += thisdsfs
gc.disable() # work round http://bugs.python.org/issue4074 on Python<2.7
for dsf in dsfs:
try:
(lat, lon, newplacements, nets, mesh) = readDSF(dsf, netdefs, {}, bbox, Exclude.TYPES[exc.name])
for placement in newplacements:
placement.load(self.lookup, self.defs, self.vertexcache, True)
placement.layout(self.tile)
if newplacements:
placements = self.placements[self.tile]
self.undostack.append(UndoEntry(self.tile, UndoEntry.ADD, [(len(placements), placement) for placement in newplacements]))
placements.extend(newplacements)
self.selected = set(newplacements)
self.selectednode = None
self.Refresh()
gc.enable()
return True
except:
if __debug__: print_exc()
gc.enable()
return False
def undo(self):
# returns new location
if not self.undostack: return False # can't happen
undo=self.undostack.pop()
self.goto(undo.tile) # force assignment of placements to layers
avlat=0
avlon=0
self.selected=set()
self.selectednode=None
placements=self.placements[undo.tile]
if undo.kind==UndoEntry.ADD:
for (i, placement) in undo.data:
placement.clearlayout()
placements.pop(i) # assumes all were added at the same index
avlat+=placement.lat
avlon+=placement.lon
elif undo.kind==UndoEntry.DEL:
for (i, placement) in undo.data:
placement.load(self.lookup, self.defs, self.vertexcache, True)
placement.layout(undo.tile)
placements.insert(i, placement)
avlat+=placement.lat
avlon+=placement.lon
self.selected.add(placement)
elif undo.kind in [UndoEntry.MOVE, UndoEntry.MODIFY]:
for (i, placement) in undo.data:
placement.load(self.lookup, self.defs, self.vertexcache, True)
placement.layout(undo.tile)
placements[i].clearlayout()
placements[i]=placement
avlat+=placement.lat
avlon+=placement.lon
self.selected.add(placement)
elif undo.kind==UndoEntry.SPLIT:
# SPLIT is like a MOVE and ADD
assert len(undo.data)==2
(i, placement) = undo.data[0]
placement.load(self.lookup, self.defs, self.vertexcache, True)
placement.layout(undo.tile)
placements[i].clearlayout()
placements[i] = placement
avlat = placement.lat*2 # Hack!
avlon = placement.lon*2
self.selected.add(placement)
(i, placement) = undo.data[1]
placement.clearlayout(self.vertexcache)
placements.pop(i)
else:
assert False, undo.kind
avlat/=len(undo.data)
avlon/=len(undo.data)
self.goto((avlat,avlon))
return (avlat,avlon)
def clearsel(self):
if self.selected:
self.Refresh()
self.selected=set()
self.selectednode=None
def allsel(self, withctrl):
# fake up mouse drag
self.clickmode=ClickModes.DragBox
self.clickpos=[0,0]
self.clickctrl=withctrl
size=self.GetClientSize()
self.mousenow=[size.x-1,size.y-1]
self.select()
self.clickmode=None
self.clickpos=None
def nextsel(self, name, withctrl, withshift):
# returns new location or None
# we have 0 or more items of the same type selected
if name.startswith(PolygonDef.EXCLUDE) or not self.lookup[name].file in self.defs:
return None # Don't have an easy way of mapping to an ExcludeDef. Placement can't exist in this tile if not loaded.
definition=self.defs[self.lookup[name].file]
placements=self.placements[self.tile]
if withctrl and withshift:
self.selected=set()
for placement in placements:
if placement.definition==definition:
self.selected.add(placement)
if not self.selected: return None
placement=list(self.selected)[0] # for position
elif withctrl:
for placement in placements:
if placement.definition==definition and placement not in self.selected:
self.selected.add(placement)
break
else:
return None
else:
start=-1
for placement in self.selected:
start=max(start,placements.index(placement))
for i in range(start+1, len(placements)+start+1):
placement=placements[i%len(placements)]
if placement.definition==definition:
self.selected=set([placement])
break
else:
return None
self.selectednode=None
self.frame.ShowSel()
return (placement.lat, placement.lon)
def getsel(self, dms=0, imp=0):
# return current selection, or average: ([names], location_string, lat, lon, object_hdg)
if not self.selected: return ([], '', None, None, None)
if self.selectednode:
placement=list(self.selected)[0]
(i,j)=self.selectednode
return ([placement.name], placement.locationstr(dms, imp, self.selectednode), placement.nodes[i][j].lat, placement.nodes[i][j].lon, None)
elif len(self.selected)==1:
placement=list(self.selected)[0]
if isinstance(placement, Polygon):
return ([placement.name], placement.locationstr(dms, imp), placement.lat, placement.lon, None)
else:
return ([placement.name], placement.locationstr(dms, imp), placement.lat, placement.lon, placement.hdg)
else:
lat=lon=0
names=[]
for placement in self.selected:
names.append(placement.name)
(tlat,tlon)=placement.location()
lat+=tlat
lon+=tlon
lat/=len(self.selected)
lon/=len(self.selected)
return (names, "%s (%d objects)" % (Clutter.latlondisp(dms, lat, lon), len(self.selected)), lat, lon, None)
def getheight(self):
# return current height
return self.y
def reload(self, prefs, airports, navaids, aptdatfile, netdefs, netfile, lookup, placements, terrain, dsfdirs):
self.valid=False
self.airports=airports # [runways] by code
self.runways={} # need to re-layout airports
self.navaids=navaids
self.navaidplacements={} # need to re-layout navaids
self.aptdatfile=aptdatfile
self.netdefs=netdefs
self.netfile=netfile # logical name of .net file used
self.codes={} # need to re-layout airports
if self.codeslist: glDeleteLists(self.codeslist, 1)
self.codeslist=0
self.lookup=lookup
self.defs={}
self.vertexcache.reset(terrain, dsfdirs)
self.imagery.reset()
self.tile=(0,999) # force reload on next goto
if not self.doneinit:
self.glInit() # would have expected an OnPaint first, but do this in case we haven't
# load networks - have to do this every reload since texcache has been reset
if netdefs:
for netdef in self.netdefs.values():
self.defs[netdef.name] = NetworkDef(netdef, self.vertexcache, self.lookup, self.defs)
if placements!=None:
self.unsorted = placements
else:
# invalidate all allocations (note: navaids just get trashed and re-loaded as required)
self.unsorted = self.placements
for placements in self.placements.values():
for placement in placements:
placement.clearlayout()
self.placements={}
self.background=None # Force reload of texture in next line
self.setbackground(prefs)
self.clipboard = set() # layers might have changed
self.undostack=[] # layers might have changed
self.selected=set() # may not have same indices in new list
self.selectednode=None
self.locked=0 # reset locked on loading new
if __debug__:
print "Frame:\t%s" % self.frame.GetId()
print "Toolb:\t%s" % self.frame.toolbar.GetId()
print "Parent:\t%s" % self.parent.GetId()
print "Split:\t%s" % self.frame.splitter.GetId()
print "MyGL:\t%s" % self.GetId()
print "Palett:\t%s" % self.frame.palette.GetId()
if 'GetChoiceCtrl' in dir(self.frame.palette):
print "Choice:\t%s" %self.frame.palette.GetChoiceCtrl().GetId()
def goto(self, latlon, hdg=None, elev=None, dist=None):
# if __debug__: print "goto", latlon
if not self.valid: return # Hack: can get spurious events on Mac during startup (progress dialogs aren't truly modal)
errdsf=None
errobjs=[]
errtexs=[]
newtile=(int(floor(latlon[0])),int(floor(latlon[1]))) # (lat,lon) of SW corner
self.centre=[newtile[0]+0.5, newtile[1]+0.5]
(self.x, self.z)=self.latlon2m(latlon[0],latlon[1])
if hdg!=None: self.h=hdg
if elev!=None: self.e=elev
if dist!=None: self.d=dist
if newtile!=self.tile or prefs.options&Prefs.REDRAW!=self.options&Prefs.REDRAW:
if newtile!=self.tile:
self.selected=set()
self.selectednode=None
self.frame.ShowSel()
self.valid=False
self.tile=newtile
self.vertexcache.flush() # clear VBOs
# forget all instance VBO allocations
for Def in self.defs.values(): Def.flush()
self.selections=set()
progress=wx.ProgressDialog('Loading', 'Terrain', 16, self.frame)
progress.SetSize
self.vertexcache.loadMesh(newtile, self.netdefs)
progress.Update(1, 'Terrain textures')
try:
self.vertexcache.getMesh(newtile) # allocates into VBO
except EnvironmentError, e:
if __debug__: print_exc()
if e.filename:
errdsf=u"%s: %s" % (e.filename, e.strerror)
else:
errdsf=unicode(e)
self.vertexcache.loadFallbackMesh(newtile)
self.vertexcache.getMesh(newtile)
except:
if __debug__: print_exc()
errdsf=unicode(exc_info()[1])
self.vertexcache.loadFallbackMesh(newtile)
self.vertexcache.getMesh(newtile)
progress.Update(2, 'Mesh')
if prefs.options&Prefs.ELEVATION!=self.options&Prefs.ELEVATION:
# Elevation preference chaged - clear all layout (other than airports)
for placements in self.placements.values() + self.navaidplacements.values():
for placement in placements:
placement.clearlayout()
else:
# Just a new tile - forget all dynamic VBO allocation
for placements in self.placements.values() + self.navaidplacements.values():
for placement in placements:
placement.flush()
# load placements
progress.Update(3, 'Objects')
if newtile in self.unsorted:
if log_load: clock=time.clock() # Processor time
placements = self.placements[newtile] = self.unsorted.pop(newtile)
# Limit progress dialog to 10 updates
p=len(placements)/10+1
n=0
i=0
for i in range(len(placements)):
if i==n:
progress.Update(3+i/p, 'Objects')
n+=p
placement=placements[i]
# Silently correct virtual names' cases
if placement.name not in self.lookup:
for existing in self.lookup.keys():
if placement.name.lower()==existing.lower():
placement.name=existing
break
#if __debug__: print placement.name
if not placement.load(self.lookup, self.defs, self.vertexcache, True) and placement.name not in errobjs:
if __debug__: print "Bad", placement.name
errobjs.append(placement.name)
self.frame.palette.markbad(placement.name)
if placement.definition.texerr:
s=u"%s: %s" % placement.definition.texerr
if not s in errtexs: errtexs.append(s)
if not placement.islaidout():
if __debug__: clock2 = time.clock()
placement.layout(newtile)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
if log_load: print "%6.3f time in load&layout" % (time.clock()-clock)
elif newtile not in self.placements:
self.placements[newtile]=[]
else:
# This tile has been previously viewed - placements are already loaded
for placement in self.placements[newtile]:
placement.layout(newtile, recalc=False) # ensure allocated
# Lay out runways
progress.Update(13, 'Airports')
key=(newtile[0],newtile[1],prefs.options&Prefs.ELEVATION)
if key not in self.runways:
if log_load: clock=time.clock() # Processor time
(self.runways[key], self.codes[newtile]) = layoutApt(newtile, self.aptdatfile, self.airports, self.vertexcache.getElevationMesh(newtile))
if log_load: print "%6.3f time in runways" % (time.clock()-clock)
(varray,shoulderlen,taxiwaylen,runwaylen,marray,mindices) = self.runways[key]
self.aptdata = {}
if shoulderlen:
self.aptdata[ClutterDef.SHOULDERLAYER] = (self.vertexcache.instance_count, shoulderlen)
if taxiwaylen:
self.aptdata[ClutterDef.TAXIWAYLAYER] = (self.vertexcache.instance_count+shoulderlen, taxiwaylen)
if runwaylen:
self.aptdata[ClutterDef.RUNWAYSLAYER] = (self.vertexcache.instance_count+shoulderlen+taxiwaylen, runwaylen)
if len(varray):
if __debug__:
for p in varray: assert p.dtype==float32 and len(p)==6, p
self.vertexcache.allocate_instance(vstack(varray)[:,:5].flatten()) # instance VBO has 5 coords
if marray:
if __debug__:
for p in marray: assert p.dtype==float32 and p.shape[1]==6, p
base = self.vertexcache.allocate_vector(vstack(marray).flatten(), mindices)
self.aptdata[ClutterDef.MARKINGSLAYER] = (base, len(mindices))
progress.Update(14, 'Navaids')
assert self.tile==newtile
if self.tile not in self.navaidplacements:
if __debug__: clock=time.clock() # Processor time
objs={2: 'lib/airport/NAVAIDS/NDB_3.obj',
3: 'lib/airport/NAVAIDS/VOR.obj',
4: 'lib/airport/NAVAIDS/ILS.obj',
5: 'lib/airport/NAVAIDS/ILS.obj',
6: 'lib/airport/NAVAIDS/glideslope.obj',
7: 'lib/airport/NAVAIDS/Marker1.obj',
8: 'lib/airport/NAVAIDS/Marker2.obj',
9: 'lib/airport/NAVAIDS/Marker2.obj',
19: '*windsock.obj',
181:'lib/airport/landscape/beacon1.obj',
182:'lib/airport/beacons/beacon_seaport.obj',
183:'lib/airport/beacons/beacon_heliport.obj',
184:'lib/airport/landscape/beacon2.obj',
185:'lib/airport/landscape/beacon1.obj',
211:'lib/airport/lights/slow/VASI.obj',
212:'lib/airport/lights/slow/PAPI.obj',
213:'lib/airport/lights/slow/PAPI.obj',
214:'lib/airport/lights/slow/PAPI.obj',
215:'lib/airport/lights/slow/VASI3.obj',
216:'lib/airport/lights/slow/rway_guard.obj',
}
placements=[]
for (i, lat, lon, hdg) in self.navaids:
if (int(floor(lat)),int(floor(lon)))==self.tile:
if i in objs:
coshdg=cos(radians(hdg))
sinhdg=sin(radians(hdg))
if i==211:
seq=[(1,75),(-1,75),(1,-75),(-1,-75)]
elif i in range(212,215):
seq=[(12,0),(4,0),(-4,0),(-12,0)]
else:
seq=[(0,0)]
for (xinc,zinc) in seq:
placement=Object(objs[i], lat, lon, hdg)
if not placement.load(self.lookup, self.defs, self.vertexcache, False):
if __debug__: print "Missing navaid %s" % objs[i]
else:
if __debug__: clock2 = time.clock()
x,z=placement.position(self.tile, lat, lon)
placement.layout(self.tile, x+xinc*coshdg-zinc*sinhdg, None, z+xinc*sinhdg+zinc*coshdg)
if __debug__: print "%6.3f time to layout %s" % (time.clock()-clock2, placement.name)
placements.append(placement)
elif __debug__: print "Missing navaid type %d" % i
self.navaidplacements[self.tile]=placements
if __debug__: print "%6.3f time in navaids" % (time.clock()-clock)
else:
# This tile has been previously viewed - placements are already loaded
for placement in self.navaidplacements[newtile]:
placement.layout(newtile, recalc=False) # ensure allocated
# labels
progress.Update(15, 'Layout')
if self.codeslist:
glDeleteLists(self.codeslist, 1)
self.codeslist=0
if __debug__ and platform=='win32':
pass # hacky workaround for https://www.virtualbox.org/ticket/8666
elif self.codes[self.tile]:
elev = self.vertexcache.getElevationMesh(self.tile)
self.codeslist=glGenLists(1)
glNewList(self.codeslist, GL_COMPILE)
glColor3f(1.0, 0.25, 0.25) # Labels are pink
glBindTexture(GL_TEXTURE_2D, 0)
for (code, (lat,lon)) in self.codes[self.tile]:
(x,z)=self.latlon2m(lat,lon)
glRasterPos3f(x, elev.height(x,z), z)
code=code.encode('latin1', 'replace')
for c in code:
glBitmap(8,13, 16,6, 8,0, fixed8x13[ord(c)])
glEndList()
# Background image - always recalc since may span multiple tiles
if self.background:
nodes=self.background.nodes[0]
for i in range(len(nodes)):
if (int(floor(nodes[i].lat)),int(floor(nodes[i].lon)))==newtile:
self.background.layout(newtile)
break
else:
self.background.clearlayout()
self.imagery.reset() # Always recalc
# Done
progress.Update(16, 'Done')
progress.Destroy()
self.valid=True
self.options = prefs.options
# cursor position
self.y = self.vertexcache.getElevationMesh(self.tile).height(self.x, self.z)
# imagery position
self.imagery.goto(latlon, self.d, self.GetClientSize())
# Redraw can happen under MessageBox, so do this last
if errdsf:
myMessageBox(errdsf, "Can't load terrain.", wx.ICON_EXCLAMATION|wx.OK, self.frame)
if errobjs:
sortfolded(errobjs)
if len(errobjs)>11: errobjs=errobjs[:10]+['and %d more objects' % (len(errobjs)-10)]
myMessageBox('\n'.join(errobjs), "Can't read one or more objects.", wx.ICON_EXCLAMATION|wx.OK, self.frame)
if errtexs:
sortfolded(errtexs)
if len(errtexs)>11: errtexs=errtexs[:10]+['and %d more textures' % (len(errtexs)-10)]
myMessageBox('\n'.join(errtexs), "Can't read one or more textures.", wx.ICON_INFORMATION|wx.OK, self.frame)
self.Refresh()
def exit(self):
# closing down
self.imagery.exit()
def getlocalloc(self, mx, my):
if not self.valid: raise Exception # MouseWheel can happen under MessageBox
if wx.VERSION >= (2,9):
self.SetCurrent(self.context)
else:
self.SetCurrent()
size = self.GetClientSize()
mx=max(0, min(size[0]-1, mx))
my=max(0, min(size[1]-1, size[1]-1-my))
self.glstate.set_instance(self.vertexcache)
self.glstate.set_texture(self.vertexcache.texcache.get(fallbacktexture)) # textured shader. ATI drivers don't like 0
self.glstate.set_depthtest(True)
self.glstate.set_poly(False) # DepthMask=True
glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE)
if prefs.options&Prefs.ELEVATION:
for (base,number,texno) in self.vertexcache.getMesh(self.tile)[0]:
glDrawArrays(GL_TRIANGLES, base, number)
else:
glBegin(GL_QUADS)
glVertex3f( onedeg*cos(radians(1+self.tile[0]))/2, 0, -onedeg/2)
glVertex3f( onedeg*cos(radians(self.tile[0]))/2, 0, onedeg/2)
glVertex3f(-onedeg*cos(radians(self.tile[0]))/2, 0, onedeg/2)
glVertex3f(-onedeg*cos(radians(1+self.tile[0]))/2, 0, -onedeg/2)
glEnd()
mz=glReadPixelsf(mx,my, 1,1, GL_DEPTH_COMPONENT)[0][0]
if mz==1.0: mz=0.5 # treat off the tile edge as sea level
(x,y,z)=gluUnProject(mx,my,mz, identity(4, float64), self.glstate.proj, array([0,0,size[0],size[1]], GLint))
glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE)
#self.SwapBuffers() # debug
glClear(GL_DEPTH_BUFFER_BIT)
#if __debug__: print "%3d %3d %.6f, %5d %5.1f %5d" % (mx,my,mz, x,y,z)
return (x,y,z)
def xz2latlon(self, x, z):
lat=round2res(self.centre[0]-z/onedeg)
lon=round2res(self.centre[1]+x/(onedeg*cos(radians(lat))))
#if __debug__: print "%11.7f %12.7f" % (lat,lon)
return (lat,lon)
def getworldloc(self, mx, my):
(x,y,z)=self.getlocalloc(mx, my)
return self.xz2latlon(x,z)
# runway tessellators
def tessvertex(vertex, data):
data.append(vertex)
def tesscombine(coords, vertex, weight):
# Linearly interp height from vertices (location, ismesh, uv)
p1=vertex[0]
p2=vertex[1]
d=hypot(p2[0][0]-p1[0][0], p2[0][2]-p1[0][2])
if not d:
return p1 # p1 and p2 are colocated
else:
ratio=hypot(coords[0]-p1[0][0], coords[2]-p1[0][2])/d
y=p1[0][1]+ratio*(p2[0][1]-p1[0][1])
return ([coords[0],y,coords[2]], False, p1[2])
def tessedge(flag):
pass # dummy
tess=gluNewTess()
gluTessNormal(tess, 0, -1, 0)
gluTessProperty(tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO)
gluTessCallback(tess, GLU_TESS_VERTEX_DATA, tessvertex)
gluTessCallback(tess, GLU_TESS_COMBINE, tesscombine)
gluTessCallback(tess, GLU_TESS_EDGE_FLAG, tessedge) # no strips
def csgtvertex((location,ismesh,uv), varray):
#assert len(location)==3, location
#assert len(uv)==2, uv
varray.append(location+uv)
def csgtcombine(coords, vertex, weight):
# vertex = [(location, ismesh, uv)]
# check for just two adjacent mesh triangles
if array_equal(vertex[0][0],vertex[1][0]) and vertex[0][1]==vertex[1][1] and vertex[0][2]==vertex[1][2]:
# common case
return vertex[0]
elif vertex[0][0][0]==vertex[1][0][0] and vertex[0][0][2]==vertex[1][0][2] and vertex[0][1]:
# Height discontinuity in terrain mesh - eg LIEE - wtf!
#assert vertex[0][1]!=vertex[1][1]
assert not weight[2] and not vertex[2] and not weight[3] and not vertex[3] and vertex[1][1]
return vertex[0]
# intersection of two lines - use terrain mesh line for height
elif vertex[0][1]:
#assert weight[0] and weight[1] and weight[2] and weight[3] and vertex[1][1]
p1=vertex[0]
p2=vertex[1]
p3=vertex[2]
else:
#assert weight[0] and weight[1] and weight[2] and weight[3] # not sure why we would assert this
p1=vertex[2]
p2=vertex[3]
p3=vertex[0]
# height
d=hypot(p2[0][0]-p1[0][0], p2[0][2]-p1[0][2])
if not d:
y=p1[0][1]
else:
ratio=(hypot(coords[0]-p1[0][0], coords[2]-p1[0][2])/d)
y=p1[0][1]+ratio*(p2[0][1]-p1[0][1])
return ([coords[0],y,coords[2]], True, p3[2] or p1[2])
def csgtedge(flag):
pass # dummy
csgt = gluNewTess()
gluTessNormal(csgt, 0, -1, 0)
gluTessProperty(csgt, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ABS_GEQ_TWO)
gluTessCallback(csgt, GLU_TESS_VERTEX_DATA, csgtvertex)
gluTessCallback(csgt, GLU_TESS_COMBINE, csgtcombine)
gluTessCallback(csgt, GLU_TESS_EDGE_FLAG, csgtedge) # no strips
| gpl-2.0 | 7,955,717,471,736,110,000 | 45.453649 | 421 | 0.577393 | false |
D0tR4ck3t33r/redis-test-chat | client.py | 1 | 2690 | import redis
_DEBUG = True
r = redis.Redis(
host='127.0.0.1',
port=6379)
# Call chat_client._keepAlive everytime a method is used
def _keep_client_alive(fn):
# The wrapper method which will get called instead of the decorated method:
def wrapper(self, *args, **kwargs):
self._keepAlive() # call the additional method
return fn(self, *args, **kwargs) # call the decorated method
return wrapper # return the wrapper method
class chat_client(object):
def __init__(self, name):
self.name = name
self.username = 'user_' + name
r.set(self.username, 1)
if _DEBUG:
print("~SET " + self.username + " 1")
r.expire(self.username, 120)
if _DEBUG:
print("~EXPIRE " + self.username + " 120")
#Methods for the online status of the client
def checkIfAlive(self):
if _DEBUG:
print("~GET " + self.username)
status = r.get(self.username)
if _DEBUG:
print("~~" + status)
if status == "1":
return True
else:
return False
def _keepAlive(self):
r.set(self.username, 1)
r.expire(self.username, 120)
if _DEBUG:
print("~SET " + self.username + ' ' + str(1))
print("~EXPIRE " + self.username + ' ' +str(120))
#General Methods e.g. List all Users
@_keep_client_alive
def listAllUsersRaw(self):
keys = r.keys('user_*')
if _DEBUG:
print("~KEYS user_*")
print("~~"+str(keys))
return keys
def listAllUsers(self):
raw_user_list = self.listAllUsersRaw()
user_list = []
for u in raw_user_list:
user_list += [u[5:]]
return user_list
#Methods Message Releated
@_keep_client_alive
def sendMessageTo(self, name, message):
key = '$user_' + name + '$' + self.username
if _DEBUG:
print("~RPUSH " + key + " \"" + message + " \"")
r.rpush(key, message)
@_keep_client_alive
def getMessagesFrom(self, name):
key = '$' + self.username + "$" + "user_" + name
messages = r.lrange(key, 0, -1)
r.delete(key)
if _DEBUG:
print("~LRANGE " + key)
print("~~" + ' '.join(messages))
print("~DEL " + key)
return messages
def getMessagesFromAll(self):
user_list = self.listAllUsers()
message_list = []
for u in user_list:
mes = self.getMessagesFrom(u)
for m in mes:
message_list += [(u, m)]
return message_list
| gpl-3.0 | 4,861,558,684,750,658,000 | 27.315789 | 79 | 0.519703 | false |
PLOS/allofplos | allofplos/elements/article_elements.py | 1 | 18523 | """These functions are for parsing individual elements of the article XML tree
Eventually these functions will probably need to be a class.
"""
import datetime
import difflib
import re
import string
import lxml.etree as et
import unidecode
def parse_article_date(date_element, date_format='%d %m %Y'):
"""
For an article date element, convert XML to a datetime object.
:param date_element: An article XML element that contains a date
:param date_format: string format used to convert to datetime object
:return: datetime object
"""
day = ''
month = ''
year = ''
for item in date_element.getchildren():
if item.tag == 'day':
day = item.text
if item.tag == 'month':
month = item.text
if item.tag == 'year':
year = item.text
if day:
date = (day, month, year)
string_date = ' '.join(date)
date = datetime.datetime.strptime(string_date, date_format)
elif month:
# try both numerical & word versions of month
date = (month, year)
string_date = ' '.join(date)
try:
date = datetime.datetime.strptime(string_date, '%m %Y')
except ValueError:
date = datetime.datetime.strptime(string_date, '%B %Y')
elif year:
date = year
date = datetime.datetime.strptime(date, '%Y')
else:
print('date error')
date = ''
return date
def get_rid_dict(contrib_element):
""" For an individual contributor, get the list of their associated rids.
More about rids: https://jats.nlm.nih.gov/archiving/tag-library/1.1/attribute/rid.html
Used in get_contrib_info().
:param contrib_element: An article XML element with the tag <contrib>
:return: dictionary matching each type of rid to its value for that contributor
"""
rid_dict = {}
contrib_elements = contrib_element.getchildren()
# get list of ref-types
rid_type_list = [el.attrib.get('ref-type', 'fn') for el in contrib_elements if el.tag == 'xref']
# make dict of ref-types to the actual ref numbers (rids)
for rid_type in set(rid_type_list):
rid_list = [el.attrib.get('rid', None) for el in contrib_elements if el.tag == 'xref' and el.attrib.get('ref-type', 'fn') == rid_type]
rid_dict[rid_type] = rid_list
return rid_dict
def get_author_type(contrib_element):
"""Get the type of author for a single contributor from their accompanying <contrib> element.
Authors can be 'corresponding' or 'contributing'. Depending on the paper, some elements have a
top-level "corresp" attribute that equal yes; otherwise, corresponding status can be inferred
from the existence of the <xref> attribute ref-type="corresp"
:param contrib_element: An article XML element with the tag <contrib>
:return: author type (corresponding, contributing, None)
"""
answer_dict = {
"yes": "corresponding",
"no": "contributing"
}
author_type = None
if contrib_element.get('contrib-type', None) == 'author':
corr = contrib_element.get('corresp', None)
if corr:
author_type = answer_dict.get(corr, None)
else:
temp = get_rid_dict(contrib_element).get('corresp', None)
if temp:
author_type = answer_dict.get("yes", None)
else:
author_type = answer_dict.get("no", None)
return author_type
def get_contrib_name(contrib_element):
"""Get the name for a single contributor from their accompanying <contrib> element.
Also constructs their initials for later matching to article-level dictionaries about
contributors, including get_aff_dict() and get_fn_dict().
Can also handle 'collab' aka group authors with a group name but no surname or given names.
:param contrib_element: An article XML element with the tag <contrib>
:return: dictionary of a single contributor's given names, surname, initials, and group name
"""
given_names = ''
surname = ''
contrib_name_element = contrib_element.find("name")
if contrib_name_element is not None:
for name_element in contrib_name_element.getchildren():
if name_element.tag == 'surname':
# for some reason, name_element.text doesn't work for this element
surname = (et.tostring(name_element,
encoding='unicode',
method='text').rstrip(' ').rstrip('\t').rstrip('\n')
or "")
elif name_element.tag == 'given-names':
given_names = name_element.text
if given_names == '':
print("given names element.text didn't work")
given_names = (et.tostring(name_element,
encoding='unicode',
method='text').rstrip(' ').rstrip('\t').rstrip('\n')
or "")
else:
pass
if given_names or surname:
# construct initials if either given or surname is present
try:
contrib_initials = ''.join([part[0].upper() for part in re.split('[-| |,|\.]+', given_names) if part]) + \
''.join([part[0] for part in re.split('[-| |,|\.]+', surname) if part[0] in string.ascii_uppercase])
except IndexError:
contrib_initials = ''
contrib_name = dict(contrib_initials=contrib_initials,
given_names=given_names,
surname=surname)
else:
# if no <name> element found, assume it's a collaboration
contrib_collab_element = contrib_element.find("collab")
group_name = et.tostring(contrib_collab_element, encoding='unicode')
group_name = re.sub('<[^>]*>', '', group_name).rstrip('\n')
if not group_name:
print("Error constructing contrib_name group element")
group_name = ''
contrib_name = dict(group_name=group_name)
return contrib_name
def get_contrib_ids(contrib_element):
"""Get the ids for a single contributor from their accompanying <contrib> element.
This will mostly get ORCID IDs, and indicate whetherh they are authenticated.
For more information of ORCIDs, see https://orcid.org/
:param contrib_element: An article XML element with the tag <contrib>
:return: list of dictionaries of ids for that contributor
"""
id_list = []
for item in contrib_element.getchildren():
if item.tag == 'contrib-id':
contrib_id_type = item.attrib.get('contrib-id-type', None)
contrib_id = item.text
contrib_authenticated = item.attrib.get('authenticated', None)
id_dict = dict(id_type=contrib_id_type,
id=contrib_id,
authenticated=contrib_authenticated
)
id_list.append(id_dict)
return id_list
def get_credit_taxonomy(contrib_element):
"""Get the contributor roles from the CREDiT taxonomy element when it is present.
Right now, this is is equivalent to author roles.
For more information about this data structure, see http://dictionary.casrai.org/Contributor_Roles
:param contrib_element: An article XML element with the tag <contrib>
:return: dictionary of contributor roles for an individual contributor
"""
credit_dict = {}
for item in contrib_element.getchildren():
if item.tag == 'role':
content_type = item.attrib.get('content-type', None)
if content_type == 'http://credit.casrai.org/':
content_type = 'CASRAI CREDiT taxonomy'
role = item.text
if not credit_dict.get(content_type, None):
credit_dict[content_type] = [role]
else:
credit_dict[content_type].append(role)
return credit_dict
def match_contrib_initials_to_dict(contrib_dict, special_dict, matched_keys, contrib_key):
"""For an individual contributor, match their initials to a dictionary.
This is used for both matching contributors to email addresses as well as credit roles,
where the keys for all dictionaries are contributor initials. In contrib_dict, these initials are
constructed from the contributor name in get_contrib_name(). For the special dicts, initials are
provided in the raw XML.
See match_contribs_to_dicts() for how this matching process is iterated across contributors.
:param contrib_dict: information about individual contributor, including their name and constructed initials
:param special_dict: usually either get_aff_dict() or get_credit_dict()
:param matched_keys: list of keys in special_dict already matched that will be excluded
:param contrib_key: The item in the contrib dictionary where the matched special_dict will be stored
:return: updated contrib_dict that includes the newly matched special_dict
"""
contributor_initials = contrib_dict.get('contrib_initials')
# special_dict keys (initials) are assumed to be uppercase
special_dict = {k.upper(): v
for k, v in special_dict.items()
if k not in matched_keys}
if contrib_dict.get('group_name', None) is None:
try:
contrib_dict[contrib_key] = special_dict[contributor_initials.upper()]
except KeyError:
# Sometimes middle initials are included or excluded, so restrict both initial sets to
# first and last initial only.
try:
contributor_abbrev_initials = ''.join([contributor_initials[0], contributor_initials[-1]])
for dict_initials, dict_value in special_dict.items():
if contributor_abbrev_initials == ''.join([dict_initials[0], dict_initials[-1]]).upper():
contrib_dict[contrib_key] = dict_value
break
except (IndexError, KeyError) as e:
pass
return contrib_dict
def get_contrib_info(contrib_element):
"""Get a dictionary of information for a single contributor from their accompanying <contrib> element.
Don't call this function directly. Instead, use as a part of get_contributors_info()
This includes all contributor information that can be directly accessed from <contrib> element contents.
However, other contributor information is stored in article-level dictionaries that need to be matched
for each contributor using the rid_dict created here.
:param contrib_element: An article XML element with the tag <contrib>
:return: dictionary of contributor name, ids/ORCID, rid_dict, author_roles
"""
# get their name
contrib_dict = get_contrib_name(contrib_element)
# get contrib type
try:
contrib_dict['contrib_type'] = contrib_element.attrib['contrib-type']
except KeyError:
# invalid contributor field; shouldn't count as contributor
return None
# get author type
if contrib_dict.get('contrib_type') == 'author':
contrib_dict['author_type'] = get_author_type(contrib_element)
elif contrib_dict.get('contrib_type') == 'editor':
for item in contrib_element.getchildren():
if item.tag == 'Role' and item.text.lower() != 'editor':
print('new editor type: {}'.format(item.text))
contrib_dict['editor_type'] = item.text
# get ORCID, if available
contrib_dict['ids'] = get_contrib_ids(contrib_element)
# get dictionary of contributor's footnote types to footnote ids
contrib_dict['rid_dict'] = get_rid_dict(contrib_element)
# get dictionary of CREDiT taxonomy, if available
contrib_dict['author_roles'] = get_credit_taxonomy(contrib_element)
return contrib_dict
def match_author_names_to_emails(corr_author_list, email_dict):
""" Finds the best match of author names to potential matching email addresses.
Don't call directly, but use as a part of match_contribs_to_dicts().
Sometimes, the initials-matching process in match_contrib_initials_to_dict() fails. When there's
at least two ummatched corresponding authors and email addresses, this function
figures out the name/email matching with the highest matching continguous character count and matches them.
This is a 'hail Mary' that thankfully also has a high rate of accuracy.
:param corr_author_list: list of contrib_dicts for corresponding authors with no email field
:param email_dict: list of unmatched author email addresses
:return: list of updated contrib_dicts for each author, now including an email field
"""
overall_matching_dict = {}
match_values = []
# Step 1: for each author and email combination, compute longest common string
for corr_author in corr_author_list:
# make single string of author full name
seq_1 = unidecode.unidecode(''.join([corr_author.get('given_names'), corr_author.get('surname')]).lower())
matching_dict = {}
for email_initials, email_address in email_dict.items():
# make string of email address that doesn't include domain
seq_2 = unidecode.unidecode(email_address[0].lower().split('@')[0])
matcher = difflib.SequenceMatcher(a=seq_1, b=seq_2)
# construct dictionary with name, email, and matching string length for each pair
match = matcher.find_longest_match(0, len(matcher.a), 0, len(matcher.b))
matching_dict[tuple(email_address)] = match[-1]
# add length of match to list of all match lengths
match_values.append(match[-1])
overall_matching_dict[(corr_author.get('given_names'), corr_author.get('surname'))] = matching_dict
# Step 2: for the author and email combination(s) with the longest common string, match them
# Iterate through max_values in descending order until all are matched
newly_matched_emails = []
newly_matched_authors = []
count = 0
while len(newly_matched_emails) < len(overall_matching_dict) and count < 20:
for k1, v1 in overall_matching_dict.items():
for k2, v2 in v1.items():
if v2 == max(match_values):
for corr_author in corr_author_list:
if k1 == (corr_author.get('given_names'), corr_author.get('surname')) \
and k2 not in newly_matched_emails and k1 not in newly_matched_authors:
corr_author['email'] = list(k2)
# keep track of matched email & author so they're not matched again
newly_matched_authors.append(k1)
newly_matched_emails.append(k2)
match_values.remove(v2)
count += 1
# Step 3: match the remaining author and email if there's only one remaining (most common)
# Might not be necessary with the while loop
still_unmatched_authors = [author for author in corr_author_list if not author.get('email')]
still_unmatched_emails = {k: v for k, v in email_dict.items() if tuple(v) not in newly_matched_emails}
if len(still_unmatched_authors) == len(still_unmatched_emails) <= 1:
if len(still_unmatched_authors) == len(still_unmatched_emails) == 1:
# only one remaining. it gets matched
still_unmatched_authors[0]['email'] = list(still_unmatched_emails.values())[0]
else:
# we were successful at matching all emails (likely, two pairs had the same match values)
pass
else:
# something's gone wrong. the candidate list of emails doesn't match the number of authors
# the corresponding authors printed below will have their ['email'] field unfilled
print('not calculating right', still_unmatched_authors, still_unmatched_emails)
return corr_author_list
def match_contribs_to_dicts(contrib_list, special_dict, contrib_key):
"""
:param contrib_list: list of contributors
:param special_dict: usually either get_aff_dict() or get_credit_dict()
:param contrib_key: The item in the contrib dictionary where the matched special_dict will be stored
"""
matching_error = False
matched_keys = []
for contrib_dict in contrib_list:
contrib_dict = match_contrib_initials_to_dict(contrib_dict,
special_dict,
matched_keys,
contrib_key)
if contrib_dict.get(contrib_key, None):
for k, v in special_dict.items():
if v == contrib_dict.get(contrib_key):
matched_keys.append(k)
if len(special_dict) == len(matched_keys):
# all special_dicts and contributors are matched
pass
else:
unmatched_special_dict = {k: v for k, v in special_dict.items()
if k not in matched_keys}
contrib_dict_missing_special_list = [contrib_dict for contrib_dict in contrib_list
if not contrib_dict.get(contrib_key, None)]
# if one contributor and one special_dict are unmatched, match them
if len(unmatched_special_dict) == len(contrib_dict_missing_special_list) == 1:
contrib_dict_missing_special_list[0][contrib_key] = list(unmatched_special_dict.values())[0]
elif len(unmatched_special_dict) != len(contrib_dict_missing_special_list):
# these numbers should always be the same
matching_error = True
else:
if contrib_key == 'email':
# match remaining contributor names to emails by string matching
contrib_dicts = match_author_names_to_emails(contrib_dict_missing_special_list, unmatched_special_dict)
if len([contrib for contrib in contrib_dicts if contrib_key not in contrib.keys()]) == 0:
# finally every contributor and special_dict is matched
pass
else:
# even after applying every strategy, there were unmatched contributors
matching_error = True
return contrib_list, matching_error
| mit | -9,046,366,052,612,875,000 | 47.362924 | 142 | 0.624791 | false |
sheerluck/andrew | seconds.py | 1 | 3114 | #-*- coding: utf-8 -*-
class Seconds(object):
def __init__(self, count):
self._seconds = count
def this(self):
return "{} seconds".format(self._seconds)
class Minute(object):
def __init__(self, count):
self._minutes = count
self._seconds = Seconds(self._minutes * 60)
def seconds(self):
return self._seconds.this()
def this(self):
return "{} minutes".format(self._minutes)
class Hour(object):
def __init__(self, count):
self._hours = count
self._minutes = Minute(self._hours * 60)
def seconds(self):
return self._minutes.seconds()
def minutes(self):
return self._minutes.this()
def this(self):
return "{} hours".format(self._hours)
class Day(object):
def __init__(self, count):
self._days = count
self._hours = Hour(self._days * 24)
def seconds(self):
return self._hours.seconds()
def minutes(self):
return self._hours.minutes()
def hours(self):
return self._hours.this()
def this(self):
return "{} days".format(self._days)
class Week(object):
def __init__(self, count):
self._weeks = count
self._days = Day(self._weeks * 7)
def seconds(self):
return self._days.seconds()
def minutes(self):
return self._days.minutes()
def hours(self):
return self._days.hours()
def days(self):
return self._days.this()
def this(self):
return "{:.1f} weeks".format(self._weeks)
class Month(object):
def __init__(self, count):
self._months = count
self._weeks = Week(self._months * 4)
def seconds(self):
return self._weeks.seconds()
def minutes(self):
return self._weeks.minutes()
def hours(self):
return self._weeks.hours()
def days(self):
return self._weeks.days()
def weeks(self):
return self._weeks.this()
def this(self):
return "{} months".format(self._months)
class Year(object):
def __init__(self, count):
self._years = count
self._months = Month(self._years * 12)
self._weeks = Week( self._years * 365/7)
self._days = Day( self._years * 365)
def seconds(self):
return self._days.seconds()
def insec(self):
return self._days._hours._minutes._seconds._seconds
def minutes(self):
return self._days.minutes()
def hours(self):
return self._days.hours()
def days(self):
return self._days.this()
def weeks(self):
return self._weeks.this()
def months(self):
return self._months.this()
def this(self):
return "{} years".format(self._years)
sec_in_year = Year(1).insec()
print(sec_in_year)
se7en_bil = 7 * 1000**3
print(se7en_bil)
years = se7en_bil / sec_in_year
print(years) # 222 years
two2two = Year(222)
print()
print(two2two.this())
print(two2two.months())
print(two2two.weeks())
print(two2two.days())
print(two2two.hours())
print(two2two.minutes())
print(two2two.seconds())
| gpl-3.0 | -4,255,883,822,636,034,000 | 19.090323 | 59 | 0.577392 | false |
aldanor/pynab | ynab/models.py | 1 | 13989 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import six
import toolz
import collections
from enum import Enum
from dateparser.date import DateDataParser
from . import schema
from .util import force_encode
class AccountType(Enum):
CHECKING = 'Checking'
SAVINGS = 'Savings'
CREDIT_CARD = 'CreditCard'
CASH = 'Cash'
LINE_OF_CREDIT = 'LineOfCredit'
PAYPAL = 'Paypal'
MERCHANT_ACCOUNT = 'MerchantAccount'
INVESTMENT_ACCOUNT = 'InvestmentAccount'
MORTGAGE = 'Mortgage'
OTHER_ASSET = 'OtherAsset'
OTHER_LIABILITY = 'OtherLiability'
class CategoryType(Enum):
OUTFLOW = 'OUTFLOW'
class TransactionStatus(Enum):
CLEARED = 'Cleared'
RECONCILED = 'Reconciled'
UNCLEARED = 'Uncleared'
class Model(object):
_entity_type = None
def __init__(self, ynab, entity):
self._ynab = ynab
self._entity = entity
@classmethod
@toolz.curry
def _from_flat(cls, ynab, data):
return cls(ynab, cls._entity_type(data, strict=False))
@property
def id(self):
return self._entity.entityId
@property
def is_valid(self):
return not self._entity.isTombstone
class Account(Model):
_entity_type = schema.Account
@force_encode
def __repr__(self):
return '<Account: {}>'.format(self.name)
@property
def name(self):
return self._entity.accountName
@property
def type(self):
return AccountType(self._entity.accountType)
@property
def on_budget(self):
return self._entity.onBudget
@property
def last_reconciled_date(self):
return self._entity.lastReconciledDate
@property
def last_reconciled_balance(self):
return self._entity.lastReconciledBalance
@property
def last_reconciled_check_number(self):
return self._entity.lastReconciledCheckNumber
@property
def hidden(self):
return self._entity.hidden
@property
def payees(self):
return self._ynab.payees.filter('target_account', self)
@property
def transactions(self):
return self._ynab.transactions.filter('account', self)
@property
def inbound_transactions(self):
return self._ynab.transactions.filter('target_account', self)
@property
def balance(self):
return round(sum(self.transactions.amount), self._ynab.precision)
@property
def cleared_balance(self):
return round(sum(self.transactions.filter('cleared').amount), self._ynab.precision)
@property
def reconciled_balance(self):
return round(sum(self.transactions.filter('reconciled').amount), self._ynab.precision)
@property
def note(self):
return self._entity.note
class Payee(Model):
_entity_type = schema.Payee
@force_encode
def __repr__(self):
return '<Payee: {}>'.format(self.name)
@property
def name(self):
return self._entity.name
@property
def target_account(self):
return self._ynab.accounts.by_id(self._entity.targetAccountId)
@property
def enabled(self):
return self._entity.enabled
@property
def transactions(self):
return self._ynab.transactions.filter('payee', self)
class CategoryModel(Model):
@property
def name(self):
return self._entity.name
@property
def type(self):
return CategoryType(self._entity.type)
class Category(CategoryModel):
_entity_type = schema.SubCategory
@force_encode
def __repr__(self):
return '<Category: {}>'.format(self.full_name)
@property
def cached_balance(self):
return self._entity.cachedBalance
@property
def master_category(self):
return self._ynab.master_categories.by_id(self._entity.masterCategoryId)
@property
def has_unresolved_conflicts(self):
return not self._entity.isResolvedConflict
@property
def note(self):
return self._entity.note
@property
def full_name(self):
return '{}/{}'.format(self.master_category.name, self.name)
@property
def transactions(self):
return self._ynab.transactions.filter('category', self)
class MasterCategory(CategoryModel):
_entity_type = schema.MasterCategory
def __init__(self, ynab, entity):
super(MasterCategory, self).__init__(ynab, entity)
self._categories = Categories(
Category(ynab, category) for category in self._entity.subCategories or [])
@force_encode
def __repr__(self):
return '<MasterCategory: {}>'.format(self.name)
@property
def categories(self):
return self._categories
def __iter__(self):
return iter(self._categories)
class TransactionModel(Model):
@property
def memo(self):
return self._entity.memo
@property
def amount(self):
return round(float(self._entity.amount or 0.), self._ynab.precision)
@property
def category(self):
return self._ynab.categories.by_id(self._entity.categoryId)
@property
def target_account(self):
return self._ynab.accounts.by_id(self._entity.targetAccountId)
@property
def transfer_transaction(self):
return self._ynab.transactions.by_id(self._entity.transferTransactionId)
@property
def has_unresolved_conflicts(self):
return not self._entity.isResolvedConflict
class SubTransaction(TransactionModel):
_entity_type = schema.SubTransaction
@force_encode
def __repr__(self):
return '<SubTransaction: {:.2f} ({})>'.format(
self.amount, self.category.name if self.category else 'no category')
@property
def parent(self):
return self._ynab.transactions.by_id(self._entity.parentTransactionId)
class Transaction(TransactionModel):
_entity_type = schema.Transaction
def __init__(self, ynab, entity):
super(Transaction, self).__init__(ynab, entity)
self._sub_transactions = SubTransactions(
SubTransaction(ynab, t) for t in self._entity.subTransactions or [])
@force_encode
def __repr__(self):
info = ''
if self.category:
info += ' ({})'.format(self.category.name)
if self.payee:
info += ' [{}]'.format(self.payee.name)
return '<Transaction: [{:%d/%m/%y}]: {}: {:.2f}{}>'.format(
self.date or 'no date', self.account.name if self.account else 'no account',
self.amount, info)
@property
def date(self):
return self._entity.date
@property
def status(self):
return TransactionStatus(self._entity.cleared)
@property
def cleared(self):
return self.status in (TransactionStatus.CLEARED, TransactionStatus.RECONCILED)
@property
def reconciled(self):
return self.status == TransactionStatus.RECONCILED
@property
def accepted(self):
return self._entity.accepted
@property
def account(self):
return self._ynab.accounts.by_id(self._entity.accountId)
@property
def payee(self):
return self._ynab.payees.by_id(self._entity.payeeId)
@property
def date_entered_from_schedule(self):
return self._entity.dateEnteredFromSchedule
@property
def sub_transactions(self):
return self._sub_transactions
class ModelCollection(collections.Sequence):
_model_type = None
_index_key = None
_NO_VALUE = object()
def __init__(self, elements):
self._elements = list(e for e in elements if e.is_valid)
# keep a reverse index for faster id indexing
self._index = {element.id: element for element in self._elements}
@classmethod
@toolz.curry
def _from_flat(cls, ynab, data):
return cls(map(cls._model_type._from_flat(ynab), data))
def __len__(self):
return len(self._elements)
def __getitem__(self, key):
# try behave both like a list and like a dict with string keys
if isinstance(key, six.string_types):
# _index_key defines the attribute name that will be matched
if self._index_key is not None:
for element in self:
if getattr(element, self._index_key) == key:
return element
raise KeyError(key)
else:
return self._elements[key]
def __getattr__(self, key):
# if the attribute is not found, propagate it to children
return [getattr(element, key) for element in self]
def __repr__(self):
# list(self) due to py2/py3 unicode problems
return repr(list(self))
def __str__(self):
# list(self) due to py2/py3 unicode problems
return str(list(self))
def by_id(self, id):
"""
Retrieve an element by entity ID. Returns None if not found.
Parameters
----------
id : str
"""
return self._index.get(id, None)
def sort_by(self, field):
"""
In-place sort by a specified field.
Parameters
----------
field : string
"""
self._elements = sorted(self._elements, key=lambda element: getattr(element, field))
def filter(self, field, value=_NO_VALUE):
"""
Filters the collection by field value of child elements.
Parameters
----------
field : str
Name of the attribute to be matched.
value : object (optional)
If specified, the values will be matched to this value by equality. Otherwise,
the values will be converted to booleans and matched to True.
Returns
-------
collection : ModelCollection
The return value is always of the same type as the original object.
"""
return type(self)(element for element in self
if (value is not self._NO_VALUE and getattr(element, field) == value) or
(value is self._NO_VALUE and getattr(element, field)))
class Accounts(ModelCollection):
_model_type = Account
_index_key = 'name'
class Payees(ModelCollection):
_model_type = Payee
_index_key = 'name'
class MasterCategories(ModelCollection):
_model_type = MasterCategory
_index_key = 'name'
class Categories(ModelCollection):
_model_type = Category
_index_key = 'full_name'
class Transactions(ModelCollection):
_model_type = Transaction
@property
def amount(self):
amount = [t.amount for t in self]
try:
# try to return a numpy array if possible
import numpy as np
return np.round(np.array(amount, dtype=np.float64), self._ynab.precision)
except ImportError:
# return a simple list otherwise
return amount
def _parse_date(self, string):
parser = DateDataParser()
date = parser.get_date_data(string)['date_obj']
if date is None:
raise RuntimeError('Unable to parse date: {!r}'.format(string))
return date.date()
def between(self, start=None, end=None):
"""
Select all transactions between the specified dates.
The dates may be specified as date objects, standard date strings ('2015-01-15') or
human-readable strings ('two weeks ago').
Parameters
----------
start : date or str (optional)
end : date or str (optional)
Returns
-------
transactions : Transactions
"""
transactions = list(self)
if start is not None:
transactions = [t for t in transactions if t.date >= self._parse_date(start)]
if end is not None:
transactions = [t for t in transactions if t.date <= self._parse_date(end)]
return type(self)(transactions)
def since(self, date):
"""
Select all transactions since the specified date.
The date may be specified as date object, standard date string ('2015-01-15') or
a human-readable string ('two weeks ago').
Parameters
----------
start : date or str
Returns
-------
transactions : Transactions
"""
return self.between(start=date)
def till(self, date):
"""
Select all transactions before and including the specified date.
The date may be specified as date object, standard date string ('2015-01-15') or
a human-readable string ('two weeks ago').
Parameters
----------
start : date or str
Returns
-------
transactions : Transactions
"""
return self.between(end=date)
class SubTransactions(ModelCollection):
_model_type = SubTransaction
class BudgetMetaData(Model):
_entity_type = schema.BudgetMetaData
_PRECISIONS = {
'ar_BH': 3,
'ar_EG': 3,
'ar_JO': 3,
'ar_KW': 3,
'ar_TN': 3,
'id_ID': 0,
'is_IS': 0,
'ja_JP': 0,
'ko_KR': 0,
'uz_Latn_UZ': 0,
}
@property
def is_valid(self):
# BudgetMetaData is not deleteable, so it is always valid.
return True
@property
def currency_locale(self):
return self._entity.currencyLocale
@property
def date_locale(self):
return self._entity.dateLocale
@property
def budget_type(self):
return self._entity.budgetType
@property
def is_strict(self):
# Is this used?
return self._entity.strictBudget
@property
def precision(self):
return self._PRECISIONS.get(self.currency_locale, 2)
class FileMetaData(Model):
_entity_type = schema.FileMetaData
@property
def current_knowledge(self):
return self._entity.currentKnowledge
@property
def id(self):
return None
@property
def is_valid(self):
return True
| bsd-3-clause | 871,299,582,886,563,200 | 24.527372 | 98 | 0.611766 | false |
tectronics/yarest | yarest/gui/_edit.py | 1 | 21660 | ## -*- coding: utf-8 -*-
# Copyright © 2011-2012 Mike Fled <[email protected]>
import re, wx
from configobj import ConfigObj
from wx.lib.intctrl import IntCtrl
from yarest import ConnectionProfile
from ._constants import (BLANK_LINES, PORT_NUMBER_MAX, PORT_NUMBER_MIN,
RESIZE_NO, RESIZE_OK)
from ._messages import (connectionprofile_list_added,
connectionprofile_list_cleared,
err_profile_name, err_unexpected, label_browse,
label_error, label_edit_window, label_profile_delete,
label_profile_name, label_profile_new,
label_profile_save, label_ssh_allow_agent,
label_ssh_allow_unknown, label_ssh_clientkeys,
label_ssh_compression, label_ssh_hostkeys,
label_ssh_port, label_ssh_search_keys,
label_ssh_server, label_ssh_username,
label_support_args, label_support_exec,
label_support_port, label_support_tunnel,
label_tcp_timeout, profile_added, profile_deleted,
profile_updated, profile_updated_name, profiles_saved,
prompt_delete_profile_message,
prompt_delete_profile_title,
tooltip_profile_name, tooltip_ssh_allow_agent,
tooltip_ssh_allow_unknown, tooltip_ssh_clientkeys,
tooltip_ssh_compression, tooltip_ssh_hostkeys,
tooltip_ssh_port, tooltip_ssh_search_keys,
tooltip_ssh_server, tooltip_ssh_username,
tooltip_support_args, tooltip_support_exec,
tooltip_support_port, tooltip_support_tunnel,
tooltip_tcp_timeout)
# layout variables
input_int_height = -1
input_int_width = 65
input_text_height = -1
input_text_width = 225
profiles_height = -1
profiles_style = wx.LB_SINGLE | wx.LB_HSCROLL | wx.LB_SORT
profiles_width = 200
input_flags = wx.ALIGN_LEFT
label_flags = wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL
button_padding = 15
grid_padding = 5
widget_padding = 7
# widget identifiers
ID_CLIENTKEYS = 2000
ID_HOSTKEYS = 2001
ID_SUPPORTEXEC = 2002
class EditProfilesDialog (wx.Dialog):
def __init__(self, parent, filename, encoding, logger, profiles, multi):
self._encoding = encoding
self._filename = filename
self._logger = logger
self._multi = multi
self._profile = None
self._profiles = profiles
self._updated = False
wx.Dialog.__init__(self, parent, wx.ID_ANY, label_edit_window,
style=wx.CLOSE_BOX | wx.MINIMIZE_BOX)
# init layout sizers
outersizer = wx.BoxSizer(wx.VERTICAL)
uppersizer = wx.BoxSizer(wx.HORIZONTAL)
formsizer = wx.FlexGridSizer(rows=0, cols=3,
vgap=grid_padding,
hgap=grid_padding)
lowersizer = wx.BoxSizer(wx.HORIZONTAL)
# profile name
label = wx.StaticText(self, wx.ID_ANY, label_profile_name)
self._profile_name = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._profile_name.SetToolTip(wx.ToolTip(tooltip_profile_name))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._profile_name, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh server
label = wx.StaticText(self, wx.ID_ANY, label_ssh_server)
self._ssh_server = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._ssh_server.SetToolTip(wx.ToolTip(tooltip_ssh_server))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_server, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh port
label = wx.StaticText(self, wx.ID_ANY, label_ssh_port)
self._ssh_port = IntCtrl(self, wx.ID_ANY,
value=None, limited=True,
size=(input_int_width,
input_int_height),
min=PORT_NUMBER_MIN, max=PORT_NUMBER_MAX,
allow_none=True, oob_color=wx.BLACK)
self._ssh_port.SetToolTip(wx.ToolTip(tooltip_ssh_port))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_port, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh username
label = wx.StaticText(self, wx.ID_ANY, label_ssh_username)
self._ssh_username = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._ssh_username.SetToolTip(wx.ToolTip(tooltip_ssh_username))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_username, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh clientkeys
label = wx.StaticText(self, wx.ID_ANY, label_ssh_clientkeys)
self._ssh_clientkeys = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._ssh_clientkeys.SetToolTip(wx.ToolTip(tooltip_ssh_clientkeys))
b_clientkeys = wx.Button(self, ID_CLIENTKEYS, label_browse)
wx.EVT_BUTTON(self, ID_CLIENTKEYS, self._on_browse_clientkeys)
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_clientkeys, RESIZE_OK, input_flags)
formsizer.Add(b_clientkeys, RESIZE_NO, input_flags)
# ssh search keys
label = wx.StaticText(self, wx.ID_ANY, label_ssh_search_keys)
self._ssh_search_keys = wx.CheckBox(self, wx.ID_ANY)
self._ssh_search_keys.SetToolTip(wx.ToolTip(tooltip_ssh_search_keys))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_search_keys, RESIZE_NO, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh allow agent
label = wx.StaticText(self, wx.ID_ANY, label_ssh_allow_agent)
self._ssh_allow_agent = wx.CheckBox(self, wx.ID_ANY)
self._ssh_allow_agent.SetToolTip(wx.ToolTip(tooltip_ssh_allow_agent))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_allow_agent, RESIZE_NO, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh hostkeys
label = wx.StaticText(self, wx.ID_ANY, label_ssh_hostkeys)
self._ssh_hostkeys = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._ssh_hostkeys.SetToolTip(wx.ToolTip(tooltip_ssh_hostkeys))
b_hostkeys = wx.Button(self, ID_HOSTKEYS, label_browse)
wx.EVT_BUTTON(self, ID_HOSTKEYS, self._on_browse_hostkeys)
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_hostkeys, RESIZE_OK, input_flags)
formsizer.Add(b_hostkeys, RESIZE_NO, input_flags)
# ssh allow unknown
label = wx.StaticText(self, wx.ID_ANY, label_ssh_allow_unknown)
self._ssh_allow_unknown = wx.CheckBox(self, wx.ID_ANY)
self._ssh_allow_unknown.SetToolTip(wx.ToolTip(tooltip_ssh_allow_unknown))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_allow_unknown, RESIZE_NO, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# ssh compression
label = wx.StaticText(self, wx.ID_ANY, label_ssh_compression)
self._ssh_compression = wx.CheckBox(self, wx.ID_ANY)
self._ssh_compression.SetToolTip(wx.ToolTip(tooltip_ssh_compression))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._ssh_compression, RESIZE_NO, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# tcp timeout
label = wx.StaticText(self, wx.ID_ANY, label_tcp_timeout)
self._tcp_timeout = IntCtrl(self, wx.ID_ANY, value=None,
size=(input_int_width,
input_int_height),
allow_none=True, oob_color=wx.BLACK)
self._tcp_timeout.SetToolTip(wx.ToolTip(tooltip_tcp_timeout))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._tcp_timeout, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# support exec
label = wx.StaticText(self, wx.ID_ANY, label_support_exec)
self._support_exec = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._support_exec.SetToolTip(wx.ToolTip(tooltip_support_exec))
b_supportexec = wx.Button(self, ID_SUPPORTEXEC, label_browse)
wx.EVT_BUTTON(self, ID_SUPPORTEXEC, self._on_browse_supportexec)
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._support_exec, RESIZE_OK, input_flags)
formsizer.Add(b_supportexec, RESIZE_NO, input_flags)
# support port
label = wx.StaticText(self, wx.ID_ANY, label_support_port)
self._support_port = IntCtrl(self, wx.ID_ANY,
value=None, limited=True,
size=(input_int_width,
input_int_height),
min=PORT_NUMBER_MIN, max=PORT_NUMBER_MAX,
allow_none=True, oob_color=wx.BLACK)
self._support_port.SetToolTip(wx.ToolTip(tooltip_support_port))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._support_port, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# support tunnel
label = wx.StaticText(self, wx.ID_ANY, label_support_tunnel)
self._support_tunnel = wx.ComboBox(self, wx.ID_ANY,
style=wx.CB_READONLY | wx.CB_SORT)
self._support_tunnel.Append("")
self._support_tunnel.Append("forward")
self._support_tunnel.Append("reverse")
self._support_tunnel.SetToolTip(wx.ToolTip(tooltip_support_tunnel))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._support_tunnel, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# support args
label = wx.StaticText(self, wx.ID_ANY, label_support_args)
self._support_args = wx.TextCtrl(self, wx.ID_ANY,
size=(input_text_width,
input_text_height))
self._support_args.SetToolTip(wx.ToolTip(tooltip_support_args))
formsizer.Add(label, RESIZE_NO, label_flags)
formsizer.Add(self._support_args, RESIZE_OK, input_flags)
formsizer.Add(self._create_empty_grid_cell(), RESIZE_NO)
# save profile and close buttons
b_save = wx.Button(self, wx.ID_SAVE, label_profile_save)
wx.EVT_BUTTON(self, wx.ID_SAVE, self._on_click_save)
b_close = wx.Button(self, wx.ID_CLOSE)
wx.EVT_BUTTON(self, wx.ID_CLOSE, self._on_click_close)
lowersizer.AddStretchSpacer()
if self._multi:
# setup delete and new profile buttons and add to lower sizer
b_delete = wx.Button(self, wx.ID_DELETE, label_profile_delete)
wx.EVT_BUTTON(self, wx.ID_DELETE, self._on_click_delete)
lowersizer.Add(b_delete, RESIZE_NO)
lowersizer.AddSpacer(button_padding)
b_new = wx.Button(self, wx.ID_NEW, label_profile_new)
wx.EVT_BUTTON(self, wx.ID_NEW, self._on_click_new)
lowersizer.Add(b_new, RESIZE_NO)
lowersizer.AddSpacer(button_padding)
# setup profiles list control and add to upper sizer
profilesizer = wx.BoxSizer(wx.HORIZONTAL)
self._profiles_list = wx.ListBox(self, wx.ID_ANY,
size=(profiles_width,
profiles_height),
style=profiles_style)
self._populate_profiles_list()
self._profiles_list.Bind(wx.EVT_LISTBOX, self._on_select_profile)
profilesizer.Add(self._profiles_list, RESIZE_NO, wx.EXPAND)
uppersizer.Add(profilesizer, RESIZE_NO,
wx.EXPAND | wx.ALL, widget_padding)
# add form sizer to upper sizer
uppersizer.Add(formsizer, RESIZE_OK, wx.ALL, widget_padding)
# add save profile and close buttons to lower sizer
lowersizer.Add(b_save, RESIZE_NO)
lowersizer.AddSpacer(button_padding)
lowersizer.Add(b_close, RESIZE_NO)
lowersizer.AddStretchSpacer()
# add upper and lower sizers to outer sizer
outersizer.Add(uppersizer, RESIZE_OK, wx.ALL, widget_padding)
outersizer.Add(lowersizer, RESIZE_NO,
wx.ALIGN_CENTER | wx.ALL, widget_padding)
# resize and theme window
self.SetIcon(parent.GetIcon())
self.SetSizerAndFit(outersizer)
self.SetThemeEnabled(True)
def _browse_for_and_set_file(self, widget):
dialog = wx.FileDialog(self, style=wx.OPEN)
if dialog.ShowModal() == wx.ID_OK:
widget.SetValue(dialog.GetPath())
dialog.Destroy()
def _create_empty_grid_cell(self):
return wx.StaticText(self, wx.ID_ANY)
def _display_error(self, error):
msgbox = wx.MessageDialog(self, str(error), label_error,
style=wx.OK | wx.ICON_ERROR)
msgbox.ShowModal()
msgbox.Destroy()
def _get_form_profile(self):
profile = ConnectionProfile(self._profile_name.GetValue())
profile.ssh_server = self._ssh_server.GetValue()
profile.ssh_port = self._ssh_port.GetValue()
profile.ssh_username = self._ssh_username.GetValue()
profile.ssh_clientkeys = self._ssh_clientkeys.GetValue()
profile.ssh_search_keys = self._ssh_search_keys.GetValue()
profile.ssh_allow_agent = self._ssh_allow_agent.GetValue()
profile.ssh_hostkeys = self._ssh_hostkeys.GetValue()
profile.ssh_allow_unknown = self._ssh_allow_unknown.GetValue()
profile.ssh_compression = self._ssh_compression.GetValue()
profile.tcp_timeout = self._tcp_timeout.GetValue()
profile.support_exec = self._support_exec.GetValue()
profile.support_port = self._support_port.GetValue()
profile.support_tunnel = self._support_tunnel.GetValue()
profile.support_args = self._support_args.GetValue()
return profile
def _on_browse_clientkeys(self, event):
self._browse_for_and_set_file(self._ssh_clientkeys)
def _on_browse_hostkeys(self, event):
self._browse_for_and_set_file(self._ssh_hostkeys)
def _on_browse_supportexec(self, event):
self._browse_for_and_set_file(self._support_exec)
def _on_click_close(self, event):
self.Close(True)
def _on_click_delete(self, event):
name = self._profiles_list.GetStringSelection()
if name != "":
msgbox = wx.MessageDialog(self,
prompt_delete_profile_message % (name),
prompt_delete_profile_title,
style=wx.YES_NO | wx.NO_DEFAULT |
wx.ICON_QUESTION)
retcode = msgbox.ShowModal()
msgbox.Destroy()
if retcode != wx.ID_YES: return
new_profiles = []
for profile in self._profiles:
if profile.name != name:
new_profiles.append(profile)
self._logger.info(profile_deleted % (name))
self._save_profiles(new_profiles)
def _on_click_new(self, event):
self._profiles_list.DeselectAll()
self._set_form_profile(None)
def _on_click_save(self, event):
profile = self._get_form_profile()
if not self._profile_is_valid(profile): return
new_profiles = []
if self._multi:
if self._profile is not None:
existing_name = self._profile.name
if profile.name == existing_name:
self._logger.info(profile_updated % (profile.name))
elif not self._profile_name_exists(profile.name):
self._logger.info(profile_updated_name %
(existing_name, profile.name))
else:
self._display_error(err_profile_name % (profile.name))
return
for p in self._profiles:
if p.name != existing_name:
new_profiles.append(p)
elif not self._profile_name_exists(profile.name):
self._logger.info(profile_added % (profile.name))
for p in self._profiles:
new_profiles.append(p)
else:
self._display_error(err_profile_name % (profile.name))
return
new_profiles.append(profile)
self._save_profiles(new_profiles)
def _on_select_profile(self, event):
if event.IsSelection():
index = self._profiles_list.GetSelection()
profile = self._profiles_list.GetClientData(index)
self._set_form_profile(profile)
def _populate_profiles_list(self):
self._profiles_list.Clear()
self._logger.debug(connectionprofile_list_cleared %
(self.__class__.__name__))
for profile in self._profiles:
self._profiles_list.Append(profile.name, profile)
self._logger.debug(connectionprofile_list_added %
(self.__class__.__name__, profile.name))
def _profile_is_valid(self, profile):
try:
ConnectionProfile.prevalidate(profile)
return True
except ValueError as e:
self._display_error(e)
return False
except Exception as e:
self._logger.exception(err_unexpected)
self._display_error(err_unexpected + BLANK_LINES + str(e))
return False
def _profile_name_exists(self, name):
pattern = r"^" + name + r"$"
for p in self._profiles:
if re.match(pattern, p.name, re.IGNORECASE) is not None:
return True
return False
def _save_profiles(self, profiles):
try:
ConnectionProfile.write_to_file(profiles,
self._filename,
self._encoding)
except Exception as e:
self._logger.exception(err_unexpected)
self._display_error(err_unexpected + BLANK_LINES + str(e))
return
self._logger.info(profiles_saved % (len(profiles), self._filename))
self._profiles = profiles
self._updated = True
if self._multi:
self._populate_profiles_list()
self._on_click_new(None)
def _set_form_profile(self, profile=None):
# we use None here for a new profile, otherwise we cache the profile
# so that we know when saving whether or not to update the existing
if profile is not None:
self._profile = profile
else:
self._profile = None
profile = ConnectionProfile("")
self._profile_name.SetValue(profile.name)
self._ssh_server.SetValue(_cstr(profile.ssh_server))
self._ssh_port.SetValue(profile.ssh_port)
self._ssh_username.SetValue(_cstr(profile.ssh_username))
self._ssh_clientkeys.SetValue(_cstr(profile.ssh_clientkeys))
self._ssh_search_keys.SetValue(_cbool(profile.ssh_search_keys))
self._ssh_allow_agent.SetValue(_cbool(profile.ssh_allow_agent))
self._ssh_hostkeys.SetValue(_cstr(profile.ssh_hostkeys))
self._ssh_allow_unknown.SetValue(_cbool(profile.ssh_allow_unknown))
self._ssh_compression.SetValue(_cbool(profile.ssh_compression))
self._tcp_timeout.SetValue(_cint(profile.tcp_timeout))
self._support_exec.SetValue(_cstr(profile.support_exec))
self._support_port.SetValue(profile.support_port)
self._support_tunnel.SetStringSelection(_cstr(profile.support_tunnel))
self._support_args.SetValue(_cstr(profile.support_args))
def GetProfiles(self):
return self._profiles
def IsUpdated(self):
return self._updated
def _cbool(value):
return value is not None and value
def _cint(value):
if value is None: return None
return int(value)
def _cstr(value):
if value is None: return ""
return str(value)
| mit | 613,162,719,687,055,700 | 44.122917 | 81 | 0.579482 | false |
Gimpneek/exclusive-raid-gym-tracker | app/features/steps/page_object_models/selectors/listing.py | 1 | 1594 | """ Selectors for list view """
from selenium.webdriver.common.by import By
TITLES = (By.CSS_SELECTOR, '.column.content > h1')
GYMS_TO_VISIT_CARDS = (
By.CSS_SELECTOR,
'#gyms_to_visit .columns > .column > .card'
)
COMPLETED_GYMS_CARDS = (
By.CSS_SELECTOR,
'#completed_gyms .columns > .column > .card'
)
CARDS = (By.CSS_SELECTOR, '.columns > .column > .card')
CARD_CONTENT = (By.CSS_SELECTOR, '.card-content')
CARD_CONTENT_TITLE = (By.CSS_SELECTOR, '.media-content > .title')
CARD_CONTENT_OSM_WAY = (
By.CSS_SELECTOR,
'.media-content > .title > i.fa.fa-tree'
)
CARD_CONTENT_EX_RAID = (
By.CSS_SELECTOR,
'.media-content > .title > i.fa.fa-ticket'
)
CARD_CONTENT_VISIT_DATE = (By.CSS_SELECTOR, '.content > p')
CARD_FOOTER = (By.CSS_SELECTOR, '.card-footer')
CARD_FOOTER_OPTION = (By.CSS_SELECTOR, '.card-footer-item')
PROGRESS_BAR = (By.CSS_SELECTOR, 'progress.progress')
PROGRESS_PERCENTAGE = (By.CSS_SELECTOR, '.hero-body h2.subtitle:last-child')
GYM_MANAGEMENT_LINK = (
By.CSS_SELECTOR,
'.hero-body h2.subtitle .is-primary.is-inverted'
)
SEARCH_BAR = (By.ID, 'gym-list-search-bar')
SEARCH_SUGGESTIONS = (
By.CSS_SELECTOR,
'#dropdown-menu .dropdown-content .dropdown-item'
)
CARD_HEADER = (By.CSS_SELECTOR, '.columns > .column > .card .raid-header')
RAID_BANNER = (By.CSS_SELECTOR, '.raid-header')
PARENT_CARD = (By.XPATH, '../../..')
def get_link_selector(button_name):
"""
Create a selector for the button with the name
:param button_name: Text on button
:return: Selector tuple
"""
return (By.LINK_TEXT, button_name)
| gpl-3.0 | -7,723,491,772,617,503,000 | 31.530612 | 76 | 0.663112 | false |
dashesy/pandas-tsdb | influxdb/indb_pd.py | 1 | 12410 | """InfluxDB interface to Pandas dataframe
Copyright Amiigo Inc.
"""
import pandas as pd
import numpy as np
import json
from indb_io import push_indb, query_indb, EmptyInput, InvalidData
def _is_null(val, zero_null=False):
"""check if value is missing
:param val: value to check
:param zero_null: if all-zero value should be treated like missing
:return:
"""
if val is None:
return True
try:
if np.all(np.isnan(val)):
return True
except:
pass
if zero_null:
try:
if np.all(np.array(val) == 0):
return True
except:
pass
return False
def _get_namespace(sensor):
"""get sensor namespace
:param sensor: namespace of the sensor, e.g. bio.bpm, activities.steps
"""
parts = sensor.split(".")
if len(parts) < 2:
return None, sensor
return ".".join(parts[0:-1]), parts[-1]
def _json_valid(val):
"""return a jason serializable value
"""
try:
json.dumps(val)
except TypeError:
if hasattr(val, 'to_json'):
return val.to_json()
if hasattr(val, 'tolist'):
return val.tolist()
if hasattr(val, 'tostring'):
return val.tostring()
# string is always good
val = str(val)
return val
class InDBJson(dict):
"""dict but my dict
"""
pass
def df_to_indb(df,
name=None,
retention_policy=None,
database=None,
tag_columns=None,
ignore_sensors=None,
labels=None,
zero_null=True,
time=None,
precision='ms',
use_iso_format=False):
"""convert dataframe to InfluxDB json body (a list of dictionaries)
convert datetime index and vectors if necessary.
:param df: dataframe; by convention the index is time and info axis has name name
:param name: if provided will be used as the measurement name.
it can be also a callable that finds measurement and sensor name from colum name
:param retention_policy: InfluxDB policy of data retention
:param database: InfluxDB database to generate json for
:param tag_columns: list of tag columns
or a callable that gets name of columns and returns if they are tags
:param ignore_sensors: name of sensors to ignore,
or a callable that returns if a column should be ignored.
:param labels: dictionary of per-frame extra tags (user_id, sensor_id, ...)
tags in labels take precedence over those in dataframe
:param zero_null: if should ignore zero readings same as missing
:param time: default per-frame timestamp of entire frame (or name of column that is time)
:param precision: required time precision
:param use_iso_format: if time should be in string format
"""
if df is None or len(df) == 0:
raise EmptyInput("Empty sensor data")
df = df.copy()
if not labels:
labels = {}
# ignore all-missing rows and columns
df = df.dropna(axis=1, how='all').dropna(axis=0, how='all')
if len(df) == 0:
raise EmptyInput("Empty sensor data")
epoch = np.datetime64('1970-01-01T00:00Z')
def _get_mname(sensor):
"""get measurement and sensor name of a sensor
"""
if callable(name):
return name(sensor)
return _get_namespace(sensor)
def _get_ts(idx, sensors):
"""find time since epoch time from index and columns
"""
try:
ts = np.array([np.datetime64(idx0) for idx0 in idx])
except:
ts = None
# try other special field for time
if ts is None:
if isinstance(time, basestring) and time in sensors:
try:
ts = sensors[time].apply(np.datetime64)
except:
ts = sensors[time].apply(np.datetime64, args=['us'])
if ts is None and time:
ts = [np.datetime64(time)]
if ts is None:
# InfluxDB backend understands if there is no time and uses now()
return ts
if use_iso_format:
# only nanosecond text is supported
return [str(np.datetime64(t, 'ns')) for t in ts]
ts = (ts - epoch) / np.timedelta64(1, precision)
ts = [int(t) for t in ts]
return ts
df['time'] = _get_ts(df.index, df)
def _is_tag(col):
if callable(tag_columns):
return tag_columns(col)
if not tag_columns:
return False
return col in tag_columns
# update labels with unique inside-df-tags that are not already in labels
for label in [tag for tag in df if _is_tag(tag) and tag not in labels]:
if len(pd.Series.unique(df[label])) == 1:
# factor out shared tag
labels[label] = df[label][0]
df.drop(label, axis=1, inplace=True)
to_precision = {
'us': 'u',
'ns': 'n',
}
points = []
data = {
'points': points,
'precision': to_precision.get(precision, precision),
}
if retention_policy:
data['retentionPolicy'] = retention_policy
if database:
data['database'] = database
if len(pd.Series.unique(df['time'])) == 1:
# factor out shared timestamp
ts = df['time'][0]
df.drop('time', axis=1, inplace=True)
if not _is_null(ts):
data['timestamp'] = ts
# common tags
if labels:
# tags key/value pairs must be both strings
labels = {str(k): str(v) for k, v in labels.iteritems()}
data['tags'] = labels
for sensors in df.itertuples():
sensors = {k: v for (k, v) in zip(df.columns, sensors[1:])}
mlabels = {}
# extract per-row tags
for sensor, val in sensors.iteritems():
sensor = str(sensor)
if _is_null(val):
continue
if _is_tag(sensor):
# tags key/value pairs must be both strings
mlabels[sensor] = str(val)
try:
ts = sensors.pop('time')
except:
ts = None
measurements = {}
for sensor, val in sensors.iteritems():
sensor = str(sensor)
if _is_null(val, zero_null=zero_null):
continue
if _is_tag(sensor):
continue
if ignore_sensors:
if callable(ignore_sensors) and ignore_sensors(sensor):
continue
if sensor in ignore_sensors:
continue
mname = name
psensor = sensor
if mname is None:
# detect measurement name based on column name
mname, psensor = _get_mname(sensor)
if not mname:
raise InvalidData('No measurement name for {sensor}'.format(sensor=sensor))
if not psensor:
raise InvalidData('No field name for {sensor}'.format(sensor=sensor))
if mname not in measurements:
measurements[mname] = {}
measurements[mname][psensor] = _json_valid(val)
for mname, fields in measurements.iteritems():
indb = {
'name': mname,
'fields': fields,
}
if not _is_null(ts):
if isinstance(ts, basestring) and np.datetime64(ts) == np.datetime64('NaT'):
raise InvalidData('Invalid NaT in time')
indb['timestamp'] = ts
if not use_iso_format:
# FIXME: not always need to specify precision for all points
indb['precision'] = to_precision.get(precision, precision)
if mlabels:
indb['tags'] = mlabels
points.append(indb)
if not points:
raise EmptyInput("Empty sensor data")
return InDBJson(data)
def dict_to_indb(data, **kwargs):
"""convert single dictionary to indb json body
Look at df_to_indb for additional arguments
"""
df = pd.DataFrame([data])
return df_to_indb(df, **kwargs)
def list_to_indb(data, **kwargs):
"""convert a list of dictionaries to indb json
Look at df_to_indb for additional arguments
"""
df = pd.DataFrame(data)
return df_to_indb(df, **kwargs)
def record_indb(auth, data,
name=None,
retention_policy=None,
database=None,
tag_columns=None,
ignore_sensors=None,
labels=None,
zero_null=True,
time=None,
precision='ms',
use_iso_format=False,
compress=False,
):
"""convert data to InfluxDB json and push it to server
"""
def _re_apply(dct):
if database:
dct['database'] = database
if retention_policy:
dct['retentionPolicy'] = retention_policy
kwargs = dict(
name=name,
retention_policy=retention_policy,
database=database,
tag_columns=tag_columns,
ignore_sensors=ignore_sensors,
labels=labels,
zero_null=zero_null,
time=time,
precision=precision,
use_iso_format=use_iso_format,
)
if isinstance(data, pd.DataFrame):
json_body = df_to_indb(data, **kwargs)
elif isinstance(data, list):
json_body = list_to_indb(data, **kwargs)
elif isinstance(data, InDBJson):
json_body = data
_re_apply(data)
elif isinstance(data, dict):
json_body = dict_to_indb(data, **kwargs)
_re_apply(data)
else:
# if unknown let it pass and maybe it can be recorded!
json_body = data
return push_indb(auth, json_body, compress=compress)
def response_to_df(data, sensor_id='sensor_id', tz='utc'):
"""convert InfluxDB response (result of a query) to dataframe
:param data: json data from InfluxDB backend
:param sensor_id: the tag that (along with time) uniquely defines a row of one sensor
:param tz: string or pytz.timezone object
"""
if not data:
return pd.DataFrame()
if isinstance(data, basestring):
data = json.loads(data)
if isinstance(data, dict):
data = data.get('results', [])
sdfs = {} # sensor dataframes
for chunk_idx, chunk in enumerate(data):
rows = chunk.get('series')
if not rows:
continue
for row in rows:
tags = row.get('tags', {})
columns = row.get('columns')
values = row.get('values')
if not columns or not values:
continue
name = row.get('name')
def _name_of(col):
if col == 'time' or not name:
return col
return '{name}.{col}'.format(col=col, name=name)
columns = [_name_of(col) for col in columns]
df = pd.DataFrame(values, columns=columns)
if 'time' in df:
df['time'] = df['time'].apply(np.datetime64)
df.set_index('time', inplace=True)
# bring back in-dataframe-tags
for tag, val in tags.iteritems():
df[tag] = val
pk = tags.get(sensor_id, 'unknown') or 'unknown'
if pk not in sdfs:
sdfs[pk] = []
sdfs[pk].append(df)
if len(sdfs) == 0:
return pd.DataFrame()
dfs = []
for ses in sdfs.itervalues():
if len(ses) == 0:
continue
df = pd.concat(ses)
dfs.append(df)
if len(dfs) == 0:
return pd.DataFrame()
data = pd.concat(dfs).sort_index()
if tz:
try:
data = data.tz_localize(tz)
except:
pass
return data
def query_indb_df(auth, query,
database=None,
chunked=False,
sensor_id='sensor_id'):
""" construct a dataframe from sensors
Look at query_indb and response_to_df for parameters
"""
data = query_indb(auth, query, database=database, chunked=chunked)
return response_to_df(data, sensor_id=sensor_id)
| bsd-3-clause | 9,087,867,320,843,652,000 | 30.025 | 93 | 0.545931 | false |
Gateswong/GatesMusicPet | music_pet/services/vgmdb.py | 1 | 5699 | # -*-: coding: utf-8 -*-
import requests
import json
import re
from ..audio import AudioTrack
LANGS = {
u"jp": (u"jp", u"Japanese"),
u"en": (u"en", u"English"),
}
def _get_json_by_link(link):
url = u'''http://vgmdb.info/%s''' % link
return _get_json(url)
def _get_json(url):
resp = requests.get(url, timeout=5)
if resp.status_code != 200:
raise Exception("Failed to search from VGMdb! Error Code = %d" % resp.status_code)
d = resp.json()
return d
# Functions with Search API
def search_all(keyword):
d = _get_json_by_link(u'''search/"%s"?format=json''' % keyword)
_validate_search_result(d)
return d[u"results"]
def search_albums(keyword):
d = _get_json_by_link(u'''search/albums/"%s"?format=json''' % keyword)
_validate_search_result(d)
return d[u"results"]
def search_artists(keyword):
d = _get_json_by_link(u'''search/artists/"%s"?format=json''' % keyword)
_validate_search_result(d)
return d[u"results"]
def search_orgs(keyword):
d = _get_json_by_link(u'''search/orgs/"%s"?format=json''' % keyword)
_validate_search_result(d)
return d[u"results"]
def search_products(keyword):
d = _get_json_by_link(u'''search/products/"%s"?format=json''' % keyword)
_validate_search_result(d)
return d[u"results"]
def _validate_search_result(search_result):
for key in [u"results", u"sections"]:
if key not in search_result:
raise ValueError("Invalid search result: field '%s' required!" % key)
for key in search_result[u"sections"]:
if key not in search_result[u"results"]:
raise ValueError("Invalid search result: in field 'results', field '%s' required!"
% key)
# Functions with Infomation API
def get_album(id):
d = _get_json_by_link(u'''album/%s''' % id)
return d
def get_artist(id):
d = _get_json_by_link(u'''artist/%s''' % id)
return d
def get_org(id):
d = _get_json_by_link(u'''org/%s''' % id)
return d
def get_product(id):
d = _get_json_by_link(u'''product/%s''' % id)
return d
def get_event(id):
d = _get_json_by_link(u'''event/%s''' % id)
return d
# Utility
def disc(num):
return u"Disc %s" % num
# Functions that producing data from JSON (dict)
def album_get_cover_picture(album_info, size="full"):
if u"covers" not in album_info:
return None
for cover_dict in album_info[u"covers"]:
if cover_dict[u"name"].lower() in [u"front", u"cover", u"folder"]:
return cover_dict[size]
def album_tracks(album_info, discname, lang=u"en"):
for disc in album_info[u"discs"]:
if disc[u"name"] == discname:
tracks = []
for track in disc[u"tracks"]:
tracks.append(track[u"names"].get(
LANGS[lang][1],
track[u"names"][u"English"]
))
return tracks
def update(album_info, track, lang=u"en"):
if not isinstance(track, AudioTrack):
raise TypeError("Instance is not a Meta object")
update_album_title(album_info, track, lang=lang)
# update_artist(album_info, track, lang=lang)
update_album_artist(album_info, track, lang=lang)
update_catalog(album_info, track, lang=lang)
update_category(album_info, track, lang=lang)
update_cover_picture(album_info, track, lang=lang)
update_title(album_info, track, lang=lang)
return
def update_album_title(album_info, track, lang=u"en"):
track.ALBUM = album_info[u"names"].get(
LANGS[lang][0],
album_info[u"names"][u"en"]
)
def update_album_artist(album_info, track, lang=u"en"):
composers = u""
for composer in album_info[u"composers"]:
composers += u", %s" % composer[u"names"].get(
LANGS[lang][0],
composer[u"names"][u"en"]
)
track.ALBUMARTIST = composers[2:]
def update_catalog(album_info, track, lang=u"en"):
if u"catalog" in album_info:
track[u"CATALOG"] = album_info[u"catalog"]
def update_category(album_info, track, lang=u"en"):
if u"category" in album_info:
track[u"CATEGORY"] = album_info[u"category"]
def update_cover_picture(album_info, track, lang=u"en"):
track[u"_picture"] = album_get_cover_picture(album_info)
def update_title(album_info, track, lang=u"en"):
if track.DISCNUMBER is None:
discname = u"Disc 1"
else:
discname = disc(track.DISCNUMBER)
track_names = album_tracks(album_info, discname, lang=lang)
track.TITLE = track_names[int(track.TRACKNUMBER) - 1]
def album_detail(album_info, lang=u"English", lang_short=u"en"):
detail_string = u""
if lang_short in album_info[u"names"]:
detail_string += u"TITLE : %s\n" % album_info[u"names"][lang_short]
else:
detail_string += u"TITLE : %s\n" % album_info[u"name"]
detail_string += u"\nCOMPOSER :\n"
for composer in album_info[u"composers"]:
if lang_short in composer[u"names"]:
detail_string += u"%s\n" % composer[u"names"][lang_short]
else:
detail_string += u"%s\n" % composer[u"names"][u"en"]
for disc in album_info[u"discs"]:
detail_string += u"\nIn : %s\n" % disc[u"name"]
for track_id, track in enumerate(disc[u"tracks"]):
detail_string += u" %s : %s\n" % (
str(track_id + 1).zfill(2),
track[u"names"][lang] if lang in track[u"names"] else track[u"names"]["English"])
return detail_string
# Functions for details
def print_album_detail(album_info, lang=u"English", lang_short=u"en"):
print(album_detail(album_info, lang, lang_short))
| mit | -4,544,880,001,078,173,000 | 25.384259 | 97 | 0.602737 | false |
vishnu2kmohan/dcos-commons | frameworks/helloworld/tests/test_secrets.py | 1 | 13700 | import logging
import pytest
import sdk_cmd
import sdk_install
import sdk_marathon
import sdk_plan
import sdk_tasks
import sdk_utils
from retrying import retry
from tests import config
log = logging.getLogger(__name__)
NUM_HELLO = 2
NUM_WORLD = 3
secret_content_default = "hello-world-secret-data"
secret_content_alternative = secret_content_default + "-alternative"
secret_options = {
"service": {
"spec_file": "examples/secrets.yml"
},
"hello": {
"count": NUM_HELLO,
"secret1": "hello-world/secret1",
"secret2": "hello-world/secret2"
},
"world": {
"count": NUM_WORLD,
"secret1": "hello-world/secret1",
"secret2": "hello-world/secret2",
"secret3": "hello-world/secret3"
}
}
options_dcos_space_test = {
"service": {
"spec_file": "examples/secrets.yml"
},
"hello": {
"count": NUM_HELLO,
"secret1": "hello-world/somePath/secret1",
"secret2": "hello-world/somePath/secret2"
},
"world": {
"count": NUM_WORLD,
"secret1": "hello-world/somePath/secret1",
"secret2": "hello-world/somePath/secret2",
"secret3": "hello-world/somePath/secret3"
}
}
@pytest.fixture(scope='module', autouse=True)
def configure_package(configure_security):
try:
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
sdk_cmd.run_cli("package install --cli dcos-enterprise-cli --yes")
delete_secrets_all("{}/".format(config.SERVICE_NAME))
delete_secrets_all("{}/somePath/".format(config.SERVICE_NAME))
delete_secrets_all()
yield # let the test session execute
finally:
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
delete_secrets_all("{}/".format(config.SERVICE_NAME))
delete_secrets_all("{}/somePath/".format(config.SERVICE_NAME))
delete_secrets_all()
@pytest.mark.sanity
@pytest.mark.smoke
@pytest.mark.secrets
@sdk_utils.dcos_ee_only
@pytest.mark.dcos_min_version('1.10')
def test_secrets_basic():
# 1) create Secrets
# 2) install examples/secrets.yml
# 3) if secret file is not created, tasks will fail
# 4) wait till deployment finishes
# 5) do replace operation
# 6) ensure all tasks are running
# 7) delete Secrets
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
create_secrets("{}/".format(config.SERVICE_NAME))
sdk_install.install(config.PACKAGE_NAME, config.SERVICE_NAME, NUM_HELLO + NUM_WORLD, additional_options=secret_options)
hello_tasks_0 = sdk_tasks.get_task_ids(config.SERVICE_NAME, "hello-0")
world_tasks_0 = sdk_tasks.get_task_ids(config.SERVICE_NAME, "word-0")
# ensure that secrets work after replace
sdk_cmd.svc_cli(config.PACKAGE_NAME, config.SERVICE_NAME, 'pod replace hello-0')
sdk_cmd.svc_cli(config.PACKAGE_NAME, config.SERVICE_NAME, 'pod replace world-0')
sdk_tasks.check_tasks_updated(config.SERVICE_NAME, "hello-0", hello_tasks_0)
sdk_tasks.check_tasks_updated(config.SERVICE_NAME, 'world-0', world_tasks_0)
# tasks will fail if secret files are not created by mesos module
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
# clean up and delete secrets
delete_secrets("{}/".format(config.SERVICE_NAME))
@pytest.mark.sanity
@pytest.mark.smoke
@pytest.mark.secrets
@sdk_utils.dcos_ee_only
@pytest.mark.dcos_min_version('1.10')
def test_secrets_verify():
# 1) create Secrets
# 2) install examples/secrets.yml
# 3) verify Secrets content
# 4) delete Secrets
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
create_secrets("{}/".format(config.SERVICE_NAME))
sdk_install.install(config.PACKAGE_NAME, config.SERVICE_NAME, NUM_HELLO + NUM_WORLD, additional_options=secret_options)
# tasks will fail if secret file is not created
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
# Verify secret content, one from each pod type
# first secret: environment variable name is given in yaml
assert secret_content_default == read_secret("world-0", "bash -c 'echo $WORLD_SECRET1_ENV'")
# second secret: file path is given in yaml
assert secret_content_default == read_secret("world-0", "cat WORLD_SECRET2_FILE")
# third secret : no file path is given in yaml
# default file path is equal to secret path
assert secret_content_default == read_secret("world-0", "cat hello-world/secret3")
# hello tasks has container image, world tasks do not
# first secret : environment variable name is given in yaml
assert secret_content_default == read_secret("hello-0", "bash -c 'echo $HELLO_SECRET1_ENV'")
# first secret : both environment variable name and file path are given in yaml
assert secret_content_default == read_secret("hello-0", "cat HELLO_SECRET1_FILE")
# second secret : file path is given in yaml
assert secret_content_default == read_secret("hello-0", "cat HELLO_SECRET2_FILE")
# clean up and delete secrets
delete_secrets("{}/".format(config.SERVICE_NAME))
@pytest.mark.sanity
@pytest.mark.smoke
@pytest.mark.secrets
@sdk_utils.dcos_ee_only
@pytest.mark.dcos_min_version('1.10')
def test_secrets_update():
# 1) create Secrets
# 2) install examples/secrets.yml
# 3) update Secrets
# 4) restart task
# 5) verify Secrets content (updated after restart)
# 6) delete Secrets
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
create_secrets("{}/".format(config.SERVICE_NAME))
sdk_install.install(config.PACKAGE_NAME, config.SERVICE_NAME, NUM_HELLO + NUM_WORLD, additional_options=secret_options)
# tasks will fail if secret file is not created
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
sdk_cmd.run_cli("security secrets update --value={} {}/secret1".format(secret_content_alternative, config.SERVICE_NAME))
sdk_cmd.run_cli("security secrets update --value={} {}/secret2".format(secret_content_alternative, config.SERVICE_NAME))
sdk_cmd.run_cli("security secrets update --value={} {}/secret3".format(secret_content_alternative, config.SERVICE_NAME))
# Verify with hello-0 and world-0, just check with one of the pods
hello_tasks_old = sdk_tasks.get_task_ids(config.SERVICE_NAME, "hello-0")
world_tasks_old = sdk_tasks.get_task_ids(config.SERVICE_NAME, "world-0")
# restart pods to retrieve new secret's content
sdk_cmd.svc_cli(config.PACKAGE_NAME, config.SERVICE_NAME, 'pod restart hello-0')
sdk_cmd.svc_cli(config.PACKAGE_NAME, config.SERVICE_NAME, 'pod restart world-0')
# wait pod restart to complete
sdk_tasks.check_tasks_updated(config.SERVICE_NAME, "hello-0", hello_tasks_old)
sdk_tasks.check_tasks_updated(config.SERVICE_NAME, 'world-0', world_tasks_old)
# wait till it is running
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
# make sure content is changed
assert secret_content_alternative == read_secret("world-0", "bash -c 'echo $WORLD_SECRET1_ENV'")
assert secret_content_alternative == read_secret("world-0", "cat WORLD_SECRET2_FILE")
assert secret_content_alternative == read_secret("world-0", "cat {}/secret3".format(config.SERVICE_NAME))
# make sure content is changed
assert secret_content_alternative == read_secret("hello-0", "bash -c 'echo $HELLO_SECRET1_ENV'")
assert secret_content_alternative == read_secret("hello-0", "cat HELLO_SECRET1_FILE")
assert secret_content_alternative == read_secret("hello-0", "cat HELLO_SECRET2_FILE")
# clean up and delete secrets
delete_secrets("{}/".format(config.SERVICE_NAME))
@pytest.mark.sanity
@pytest.mark.secrets
@pytest.mark.smoke
@sdk_utils.dcos_ee_only
@pytest.mark.dcos_min_version('1.10')
def test_secrets_config_update():
# 1) install examples/secrets.yml
# 2) create new Secrets, delete old Secrets
# 2) update configuration with new Secrets
# 4) verify secret content (using new Secrets after config update)
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
create_secrets("{}/".format(config.SERVICE_NAME))
sdk_install.install(config.PACKAGE_NAME, config.SERVICE_NAME, NUM_HELLO + NUM_WORLD, additional_options=secret_options)
# tasks will fail if secret file is not created
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
# Verify secret content, one from each pod type
# make sure it has the default value
assert secret_content_default == read_secret("world-0", "bash -c 'echo $WORLD_SECRET1_ENV'")
assert secret_content_default == read_secret("world-0", "cat WORLD_SECRET2_FILE")
assert secret_content_default == read_secret("world-0", "cat {}/secret3".format(config.SERVICE_NAME))
# hello tasks has container image
assert secret_content_default == read_secret("hello-0", "bash -c 'echo $HELLO_SECRET1_ENV'")
assert secret_content_default == read_secret("hello-0", "cat HELLO_SECRET1_FILE")
assert secret_content_default == read_secret("hello-0", "cat HELLO_SECRET2_FILE")
# clean up and delete secrets (defaults)
delete_secrets("{}/".format(config.SERVICE_NAME))
# create new secrets with new content -- New Value
create_secrets(secret_content_arg=secret_content_alternative)
marathon_config = sdk_marathon.get_config(config.SERVICE_NAME)
marathon_config['env']['HELLO_SECRET1'] = 'secret1'
marathon_config['env']['HELLO_SECRET2'] = 'secret2'
marathon_config['env']['WORLD_SECRET1'] = 'secret1'
marathon_config['env']['WORLD_SECRET2'] = 'secret2'
marathon_config['env']['WORLD_SECRET3'] = 'secret3'
# config update
sdk_marathon.update_app(config.SERVICE_NAME, marathon_config)
# wait till plan is complete - pods are supposed to restart
sdk_plan.wait_for_completed_deployment(config.SERVICE_NAME)
# all tasks are running
sdk_tasks.check_running(config.SERVICE_NAME, NUM_HELLO + NUM_WORLD)
# Verify secret content is changed
assert secret_content_alternative == read_secret("world-0", "bash -c 'echo $WORLD_SECRET1_ENV'")
assert secret_content_alternative == read_secret("world-0", "cat WORLD_SECRET2_FILE")
assert secret_content_alternative == read_secret("world-0", "cat secret3")
assert secret_content_alternative == read_secret("hello-0", "bash -c 'echo $HELLO_SECRET1_ENV'")
assert secret_content_alternative == read_secret("hello-0", "cat HELLO_SECRET1_FILE")
assert secret_content_alternative == read_secret("hello-0", "cat HELLO_SECRET2_FILE")
# clean up and delete secrets
delete_secrets()
@pytest.mark.sanity
@pytest.mark.smoke
@pytest.mark.secrets
@sdk_utils.dcos_ee_only
@pytest.mark.dcos_min_version('1.10')
def test_secrets_dcos_space():
# 1) create secrets in hello-world/somePath, i.e. hello-world/somePath/secret1 ...
# 2) Tasks with DCOS_SPACE hello-world/somePath
# or some DCOS_SPACE path under hello-world/somePath
# (for example hello-world/somePath/anotherPath/)
# can access these Secrets
sdk_install.uninstall(config.PACKAGE_NAME, config.SERVICE_NAME)
# cannot access these secrets because of DCOS_SPACE authorization
create_secrets("{}/somePath/".format(config.SERVICE_NAME))
try:
sdk_install.install(
config.PACKAGE_NAME,
config.SERVICE_NAME,
NUM_HELLO + NUM_WORLD,
additional_options=options_dcos_space_test,
timeout_seconds=5 * 60) # Wait for 5 minutes. We don't need to wait 15 minutes for hello-world to fail an install
assert False, "Should have failed to install"
except AssertionError as arg:
raise arg
except:
pass # expected to fail
# clean up and delete secrets
delete_secrets("{}/somePath/".format(config.SERVICE_NAME))
def create_secrets(path_prefix="", secret_content_arg=secret_content_default):
sdk_cmd.run_cli("security secrets create --value={} {}secret1".format(secret_content_arg, path_prefix))
sdk_cmd.run_cli("security secrets create --value={} {}secret2".format(secret_content_arg, path_prefix))
sdk_cmd.run_cli("security secrets create --value={} {}secret3".format(secret_content_arg, path_prefix))
def delete_secrets(path_prefix=""):
sdk_cmd.run_cli("security secrets delete {}secret1".format(path_prefix))
sdk_cmd.run_cli("security secrets delete {}secret2".format(path_prefix))
sdk_cmd.run_cli("security secrets delete {}secret3".format(path_prefix))
def delete_secrets_all(path_prefix=""):
# if there is any secret left, delete
# use in teardown_module
try:
sdk_cmd.run_cli("security secrets get {}secret1".format(path_prefix))
sdk_cmd.run_cli("security secrets delete {}secret1".format(path_prefix))
except:
pass
try:
sdk_cmd.run_cli("security secrets get {}secret2".format(path_prefix))
sdk_cmd.run_cli("security secrets delete {}secret2".format(path_prefix))
except:
pass
try:
sdk_cmd.run_cli("security secrets get {}secret3".format(path_prefix))
sdk_cmd.run_cli("security secrets delete {}secret3".format(path_prefix))
except:
pass
@retry
def read_secret(task_name, command):
cmd_str = "task exec {} {}".format(task_name, command)
lines = sdk_cmd.run_cli(cmd_str).split('\n')
log.info('dcos %s output: %s', cmd_str, lines)
for i in lines:
if i.strip().startswith(secret_content_default):
return i
raise Exception("Failed to read secret")
| apache-2.0 | -7,747,007,387,317,984,000 | 37.055556 | 125 | 0.685255 | false |
adviti/melange | app/soc/modules/gsoc/views/proposal_review.py | 1 | 33758 | #!/usr/bin/env python2.5
#
# Copyright 2011 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Module for the GSoC proposal page.
"""
from google.appengine.ext import db
from django.core.urlresolvers import resolve
from django.core.urlresolvers import reverse
from django import forms as django_forms
from django.utils.translation import ugettext
from soc.logic import cleaning
from soc.logic.exceptions import BadRequest
from soc.logic.helper import notifications
from soc.views.helper import url as url_helper
from soc.views.helper.access_checker import isSet
from soc.views.template import Template
from soc.views.toggle_button import ToggleButtonTemplate
from soc.tasks import mailer
from soc.modules.gsoc.logic import profile as profile_logic
from soc.modules.gsoc.models.comment import GSoCComment
from soc.modules.gsoc.models.proposal_duplicates import GSoCProposalDuplicate
from soc.modules.gsoc.models.profile import GSoCProfile
from soc.modules.gsoc.models.score import GSoCScore
from soc.modules.gsoc.views import assign_mentor
from soc.modules.gsoc.views.base import RequestHandler
from soc.modules.gsoc.views.forms import GSoCModelForm
from soc.modules.gsoc.views.helper import url_patterns
from soc.modules.gsoc.views.helper.url_patterns import url
class CommentForm(GSoCModelForm):
"""Django form for the comment.
"""
class Meta:
model = GSoCComment
#css_prefix = 'gsoc_comment'
fields = ['content']
def clean_content(self):
field_name = 'content'
wrapped_clean_html_content = cleaning.clean_html_content(field_name)
content = wrapped_clean_html_content(self)
if content:
return content
else:
raise django_forms.ValidationError(
ugettext('Comment content cannot be empty.'), code='invalid')
def templatePath(self):
return 'v2/modules/gsoc/proposal/_comment_form.html'
class PrivateCommentForm(CommentForm):
"""Django form for the comment.
"""
class Meta:
model = GSoCComment
fields = CommentForm.Meta.fields + ['is_private']
class Duplicate(Template):
"""Template for showing a duplicates to the org admin.
"""
def __init__(self, data, duplicate):
"""Instantiates the template for rendering duplicates for a single
proposal.
Args:
data: RequestData object
duplicate: GSoCProposalDuplicate entity to render.
"""
self.duplicate = duplicate
super(Duplicate, self).__init__(data)
def context(self):
"""The context for this template used in render().
"""
r = self.data.redirect
orgs = []
for org in db.get(self.duplicate.orgs):
q = GSoCProfile.all()
q.filter('org_admin_for', org)
q.filter('status', 'active')
admins = q.fetch(1000)
data = {'name': org.name,
'link': r.organization(org).urlOf('gsoc_org_home'),
'admins': admins}
orgs.append(data)
context = {'orgs': orgs}
return context
def templatePath(self):
return 'v2/modules/gsoc/duplicates/proposal_duplicate_review.html'
class UserActions(Template):
"""Template to render the left side user actions.
"""
DEF_ACCEPT_PROPOSAL_HELP = ugettext(
'Choosing Yes will mark this proposal as accepted. The proposal is '
'accepted when Yes is displayed in bright orange.')
DEF_IGNORE_PROPOSAL_HELP = ugettext(
'Choosing Yes will mark this proposal as ignored. The student will be '
'be able to see that this proposal is ignored when he/she visits this '
'page. The proposal is ignored when Yes is displayed in bright orange.')
DEF_IGNORE_PROPOSAL_NOTE = ugettext(
'Please refresh this page after setting this preference.')
DEF_PROPOSAL_MODIFICATION_HELP = ugettext(
'Choosing Enabled allows the student to edit this proposal. The '
'student can edit the proposal when Enabled is displayed in bright '
'orange.')
DEF_PUBLICLY_VISIBLE_HELP = ugettext(
'Choosing Yes will make this proposal publicly visible. The proposal '
'will be visible to even those who do not have a user account on this '
'site. The proposal is publicly visible when Yes is displayed in '
'bright orange')
DEF_WISH_TO_MENTOR_HELP = ugettext(
'Choosing Yes will add your name to the list of possible mentors to '
'this proposal. You will be listed as a possible mentor when Yes is '
'displayed in bright orange.')
DEF_WITHDRAW_PROPOSAL_HELP = ugettext(
'Choosing Yes, notifies your organization that you have withdrawn '
'this proposal and no longer wish to participate in the program with '
'this proposal. The proposal is withdrawn when the button displays '
'Yes in bright orange.')
def __init__(self, data, user_role):
super(UserActions, self).__init__(data)
self.user_role = user_role
self.toggle_buttons = []
def _mentorContext(self):
"""Construct the context needed for mentor actions.
"""
r = self.data.redirect.review()
wish_to_mentor = ToggleButtonTemplate(
self.data, 'on_off', 'Wish to Mentor', 'wish-to-mentor',
r.urlOf('gsoc_proposal_wish_to_mentor'),
checked=self.data.isPossibleMentorForProposal(),
help_text=self.DEF_WISH_TO_MENTOR_HELP,
labels = {
'checked': 'Yes',
'unchecked': 'No'})
self.toggle_buttons.append(wish_to_mentor)
if self.data.timeline.afterStudentSignupEnd():
proposal_modification_button = ToggleButtonTemplate(
self.data, 'long', 'Proposal Modifications', 'proposal-modification',
r.urlOf('gsoc_proposal_modification'),
checked=self.data.proposal.is_editable_post_deadline,
help_text=self.DEF_PROPOSAL_MODIFICATION_HELP,
labels = {
'checked': 'Enabled',
'unchecked': 'Disabled'})
self.toggle_buttons.append(proposal_modification_button)
return {}
def _orgAdminContext(self):
"""Construct the context needed for org admin actions.
"""
context = {}
r = self.data.redirect.review()
ignore_button_checked = False
if self.data.proposal.status == 'ignored':
ignore_button_checked = True
if self.data.proposal.status in ['pending', 'withdrawn', 'ignored']:
ignore_proposal = ToggleButtonTemplate(
self.data, 'on_off', 'Ignore Proposal', 'proposal-ignore',
r.urlOf('gsoc_proposal_ignore'),
checked=ignore_button_checked,
help_text=self.DEF_IGNORE_PROPOSAL_HELP,
note=self.DEF_IGNORE_PROPOSAL_NOTE,
labels={
'checked': 'Yes',
'unchecked': 'No'})
self.toggle_buttons.append(ignore_proposal)
if not self.proposal_ignored:
accept_proposal = ToggleButtonTemplate(
self.data, 'on_off', 'Accept proposal', 'accept-proposal',
r.urlOf('gsoc_proposal_accept'),
checked=self.data.proposal.accept_as_project,
help_text=self.DEF_ACCEPT_PROPOSAL_HELP,
labels = {
'checked': 'Yes',
'unchecked': 'No',})
self.toggle_buttons.append(accept_proposal)
r = self.data.redirect
possible_mentors_keys = self.data.proposal.possible_mentors
all_mentors_keys = profile_logic.queryAllMentorsKeysForOrg(
self.data.proposal_org)
context['assign_mentor'] = assign_mentor.AssignMentorFields(
self.data, self.data.proposal.mentor,
r.review().urlOf('gsoc_proposal_assign_mentor'),
possible_mentors_keys, all_mentors_keys)
return context
def _proposerContext(self):
"""Construct the context needed for proposer actions.
"""
r = self.data.redirect.review()
publicly_visible = ToggleButtonTemplate(
self.data, 'on_off', 'Publicly Visible', 'publicly-visible',
r.urlOf('gsoc_proposal_publicly_visible'),
checked=self.data.proposal.is_publicly_visible,
help_text=self.DEF_PUBLICLY_VISIBLE_HELP,
labels = {
'checked': 'Yes',
'unchecked': 'No',})
self.toggle_buttons.append(publicly_visible)
if self.data.proposal.status in ['pending', 'withdrawn']:
if self.data.proposal.status == 'withdrawn':
checked=True
elif self.data.proposal.status == 'pending':
checked=False
withdraw_proposal = ToggleButtonTemplate(
self.data, 'on_off', 'Withdraw Proposal', 'withdraw-proposal',
r.urlOf('gsoc_proposal_withdraw'), checked=checked,
help_text=self.DEF_WITHDRAW_PROPOSAL_HELP,
labels = {
'checked': 'Yes',
'unchecked': 'No',})
self.toggle_buttons.append(withdraw_proposal)
return {}
def context(self):
assert isSet(self.data.proposal)
context = {
'title': 'Proposal Actions',
}
self.proposal_ignored = self.data.proposal.status == 'ignored'
if self.user_role == 'mentor' and not self.proposal_ignored:
context.update(self._mentorContext())
if self.user_role == 'org_admin':
context.update(self._orgAdminContext())
# org admin is a mentor by default so add that context and buttons
# as well.
if not self.proposal_ignored:
context.update(self._mentorContext())
if self.user_role == 'proposer':
context.update(self._proposerContext())
context['toggle_buttons'] = self.toggle_buttons
return context
def templatePath(self):
return "v2/modules/gsoc/proposal/_user_action.html"
class ReviewProposal(RequestHandler):
"""View for the Propsal Review page.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/review/%s$' % url_patterns.REVIEW,
self, name='review_gsoc_proposal'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
self.check.canAccessProposalEntity()
self.mutator.commentVisible()
def templatePath(self):
return 'v2/modules/gsoc/proposal/review.html'
def getScores(self):
"""Gets all the scores for the proposal.
"""
assert isSet(self.data.private_comments_visible)
assert isSet(self.data.proposal_org)
assert isSet(self.data.proposal)
if not self.data.private_comments_visible:
return None
total = 0
number = 0
user_score = 0
query = db.Query(GSoCScore).ancestor(self.data.proposal)
for score in query:
total += score.value
number += 1
author_key = GSoCScore.author.get_value_for_datastore(score)
if author_key == self.data.profile.key():
user_score = score.value
return {
'average': total / number if number else 0,
'number': number,
'total': total,
'user_score': user_score,
}
def getComments(self, limit=1000):
"""Gets all the comments for the proposal visible by the current user.
"""
assert isSet(self.data.private_comments_visible)
assert isSet(self.data.proposal)
public_comments = []
private_comments = []
query = db.Query(GSoCComment).ancestor(self.data.proposal)
query.order('created')
all_comments = query.fetch(limit=limit)
for comment in all_comments:
if not comment.is_private:
public_comments.append(comment)
elif self.data.private_comments_visible:
private_comments.append(comment)
return public_comments, private_comments
def sanitizePossibleMentors(self, possible_mentors):
"""Removes possible mentors that are no longer mentors
"""
changed = False
result = []
for mentor in possible_mentors:
if self.data.proposal_org.key() in mentor.mentor_for:
result.append(mentor)
continue
changed = True
self.data.proposal.possible_mentors.remove(mentor.key())
if changed:
self.data.proposal.put()
return result
def context(self):
assert isSet(self.data.public_comments_visible)
assert isSet(self.data.private_comments_visible)
assert isSet(self.data.url_profile)
assert isSet(self.data.url_user)
assert isSet(self.data.proposal)
context = {}
user_role = None
scores = self.getScores()
# TODO: check if the scoring is not disabled
score_action = reverse('score_gsoc_proposal', kwargs=self.data.kwargs)
# get all the comments for the the proposal
public_comments, private_comments = self.getComments()
# TODO: check if it is possible to post a comment
comment_action = reverse('comment_gsoc_proposal', kwargs=self.data.kwargs)
if self.data.private_comments_visible:
form = PrivateCommentForm(self.data.POST or None)
if self.data.orgAdminFor(self.data.proposal.org):
user_role = 'org_admin'
else:
user_role = 'mentor'
else:
form = CommentForm(self.data.POST or None)
comment_box = {
'action': comment_action,
'form': form,
}
# to keep the blocks as simple as possible, the if branches have
# been broken down into several if blocks
user_is_proposer = self.data.user and \
(self.data.user.key() == self.data.url_user.key())
if user_is_proposer:
user_role = 'proposer'
# we will check if the student is allowed to modify the proposal
# after the student proposal deadline
is_editable = self.data.timeline.afterStudentSignupEnd() and \
self.data.proposal.is_editable_post_deadline
if self.data.timeline.studentSignup() or is_editable:
context['update_link'] = self.data.redirect.id().urlOf(
'update_gsoc_proposal')
possible_mentors = db.get(self.data.proposal.possible_mentors)
possible_mentors = self.sanitizePossibleMentors(possible_mentors)
possible_mentors_names = ', '.join([m.name() for m in possible_mentors])
scoring_visible = self.data.private_comments_visible and (
not self.data.proposal_org.scoring_disabled)
if self.data.orgAdminFor(self.data.proposal_org):
scoring_visible = True
duplicate = None
if self.data.program.duplicates_visible and self.data.orgAdminFor(
self.data.proposal_org):
q = GSoCProposalDuplicate.all()
q.filter('duplicates', self.data.proposal)
q.filter('is_duplicate', True)
dup_entity = q.get()
duplicate = Duplicate(self.data, dup_entity) if dup_entity else None
additional_info = self.data.proposal.additional_info
if user_role:
context['user_actions'] = UserActions(self.data, user_role)
context.update({
'additional_info': url_helper.trim_url_to(additional_info, 50),
'additional_info_link': additional_info,
'comment_box': comment_box,
'duplicate': duplicate,
'max_score': self.data.proposal_org.max_score,
'mentor': self.data.proposal.mentor,
'page_name': self.data.proposal.title,
'possible_mentors': possible_mentors_names,
'private_comments': private_comments,
'private_comments_visible': self.data.private_comments_visible,
'proposal': self.data.proposal,
'public_comments': public_comments,
'public_comments_visible': self.data.public_comments_visible,
'score_action': score_action,
'scores': scores,
'scoring_visible': scoring_visible,
'student_email': self.data.url_profile.email,
'student_name': self.data.url_profile.name(),
'proposal_ignored': self.data.proposal.status == 'ignored',
'user_role': user_role,
})
return context
class PostComment(RequestHandler):
"""View which handles publishing comments.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/comment/%s$' % url_patterns.REVIEW,
self, name='comment_gsoc_proposal'),
]
def checkAccess(self):
self.check.isProgramVisible()
self.check.isProfileActive()
self.mutator.proposalFromKwargs()
self.mutator.commentVisible()
assert isSet(self.data.proposer)
assert isSet(self.data.proposal_org)
# check if the comment is given by the author of the proposal
if self.data.proposer.key() == self.data.profile.key():
self.data.public_only = True
return
self.data.public_only = False
self.check.isMentorForOrganization(self.data.proposal_org)
def createCommentFromForm(self):
"""Creates a new comment based on the data inserted in the form.
Returns:
a newly created comment entity or None
"""
assert isSet(self.data.public_only)
assert isSet(self.data.proposal)
if self.data.public_only:
comment_form = CommentForm(self.data.request.POST)
else:
# this form contains checkbox for indicating private/public comments
comment_form = PrivateCommentForm(self.data.request.POST)
if not comment_form.is_valid():
return None
if self.data.public_only:
comment_form.cleaned_data['is_private'] = False
comment_form.cleaned_data['author'] = self.data.profile
q = GSoCProfile.all().filter('mentor_for', self.data.proposal.org)
q = q.filter('status', 'active')
if comment_form.cleaned_data.get('is_private'):
q.filter('notify_private_comments', True)
else:
q.filter('notify_public_comments', True)
mentors = q.fetch(1000)
to_emails = [i.email for i in mentors \
if i.key() != self.data.profile.key()]
def create_comment_txn():
comment = comment_form.create(commit=True, parent=self.data.proposal)
context = notifications.newCommentContext(self.data, comment, to_emails)
sub_txn = mailer.getSpawnMailTaskTxn(context, parent=comment)
sub_txn()
return comment
return db.run_in_transaction(create_comment_txn)
def post(self):
assert isSet(self.data.proposer)
assert isSet(self.data.proposal)
comment = self.createCommentFromForm()
if comment:
self.redirect.program()
self.redirect.to('gsoc_dashboard')
else:
# This is an insanely and absolutely hacky solution. We definitely
# do not want any one to use this a model for writing code elsewhere
# in Melange.
# TODO (Madhu): Replace this in favor of PJAX for loading comments.
r = self.redirect.review(self.data.proposal.key().id(),
self.data.proposer.link_id)
redirect_url = r.urlOf('review_gsoc_proposal')
proposal_match = resolve(redirect_url)
proposal_view = proposal_match[0]
self.request.method = 'GET'
self.response = proposal_view(self.request, *self.args, **self.kwargs)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class PostScore(RequestHandler):
"""View which handles posting scores.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/score/%s$' % url_patterns.REVIEW,
self, name='score_gsoc_proposal'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
org = self.data.proposal_org
if not self.data.orgAdminFor(org) and org.scoring_disabled:
raise BadRequest('Scoring is disabled for this organization')
self.check.isMentorForOrganization(org)
def createOrUpdateScore(self, value):
"""Creates a new score or updates a score if there is already one
posted by the current user.
If the value passed in is 0 then the Score of the user will be removed and
None will be returned.
Args:
value: The value of the score the user gave as an integer.
Returns:
The score entity that was created/updated or None if value is 0.
"""
assert isSet(self.data.proposal)
assert isSet(self.data.proposal_org)
max_score = self.data.proposal_org.max_score
if value < 0 or value > max_score:
raise BadRequest("Score must not be higher than %d" % max_score)
query = db.Query(GSoCScore)
query.filter('author = ', self.data.profile)
query.ancestor(self.data.proposal)
def update_score_trx():
delta = 0
# update score entity
score = query.get()
if not score:
if not value:
return
old_value = 0
score = GSoCScore(
parent=self.data.proposal,
author=self.data.profile,
value=value)
score.put()
delta = 1
else:
old_value = score.value
if not value:
delta = -1
score.delete()
else:
score.value = value
score.put()
# update total score for the proposal
proposal = db.get(self.data.proposal.key())
proposal.score += value - old_value
proposal.nr_scores += delta
proposal.put()
db.run_in_transaction(update_score_trx)
def post(self):
value_str = self.data.POST.get('value', '')
value = int(value_str) if value_str.isdigit() else None
self.createOrUpdateScore(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class WishToMentor(RequestHandler):
"""View handling wishing to mentor requests.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/wish_to_mentor/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_wish_to_mentor'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
self.check.isMentorForOrganization(self.data.proposal_org)
def addToPotentialMentors(self, value):
"""Toggles the user from the potential mentors list.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.profile)
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and not self.data.isPossibleMentorForProposal():
raise BadRequest("Invalid post data.")
if value == 'unchecked' and self.data.isPossibleMentorForProposal():
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
profile_key = self.data.profile.key()
def update_possible_mentors_trx():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
# we have already been added
if profile_key in proposal.possible_mentors:
return
proposal.possible_mentors.append(profile_key)
else:
# we have already been removed
if profile_key not in proposal.possible_mentors:
return
proposal.possible_mentors.remove(profile_key)
db.put(proposal)
db.run_in_transaction(update_possible_mentors_trx)
def post(self):
value = self.data.POST.get('value')
self.addToPotentialMentors(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class AssignMentor(RequestHandler):
"""View which handles assigning mentor to a proposal.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/assign_mentor/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_assign_mentor'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
self.check.isOrgAdminForOrganization(self.data.proposal_org)
def assignMentor(self, mentor_entity):
"""Assigns the mentor to the proposal.
Args:
mentor_entity: The entity of the mentor profile which needs to assigned
to the proposal.
"""
assert isSet(self.data.proposal)
proposal_key = self.data.proposal.key()
def assign_mentor_txn():
proposal = db.get(proposal_key)
proposal.mentor = mentor_entity
proposal.has_mentor = True
db.put(proposal)
db.run_in_transaction(assign_mentor_txn)
def unassignMentor(self):
"""Removes the mentor assigned to the proposal.
"""
assert isSet(self.data.proposal)
proposal_key = self.data.proposal.key()
def unassign_mentor_txn():
proposal = db.get(proposal_key)
proposal.mentor = None
proposal.has_mentor = False
db.put(proposal)
db.run_in_transaction(unassign_mentor_txn)
def validate(self):
mentor_key = self.data.POST.get('assign_mentor')
if mentor_key:
mentor_entity = db.get(mentor_key)
org = self.data.proposal.org
if mentor_entity and self.data.isPossibleMentorForProposal(
mentor_entity) or (org.list_all_mentors
and db.Key(mentor_key) in profile_logic.queryAllMentorsKeysForOrg(
org)):
return mentor_entity
else:
raise BadRequest("Invalid post data.")
return None
def post(self):
assert isSet(self.data.proposal)
mentor_entity= self.validate()
if mentor_entity:
self.assignMentor(mentor_entity)
else:
self.unassignMentor()
self.data.proposer = self.data.proposal.parent()
self.redirect.review(self.data.proposal.key().id(),
self.data.proposer.link_id)
self.redirect.to('review_gsoc_proposal')
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class IgnoreProposal(RequestHandler):
"""View which allows org admins to ignore a proposal.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/ignore/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_ignore'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
self.check.isOrgAdminForOrganization(self.data.proposal_org)
def toggleIgnoreProposal(self, value):
"""Toggles the ignore status of the proposal.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and self.data.proposal.status != 'ignored':
raise BadRequest("Invalid post data.")
if value == 'unchecked' and self.data.proposal.status not in [
'pending', 'withdrawn']:
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
def update_status_txn():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
proposal.status = 'ignored'
elif value == 'checked':
proposal.status = 'pending'
db.put(proposal)
db.run_in_transaction(update_status_txn)
def post(self):
value = self.data.POST.get('value')
self.toggleIgnoreProposal(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class ProposalModificationPostDeadline(RequestHandler):
"""View allowing mentors to allow students to modify the proposal.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/modification/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_modification'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
self.check.isMentorForOrganization(self.data.proposal_org)
def toggleModificationPermission(self, value):
"""Toggles the permission to modify the proposal after proposal deadline.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and not self.data.proposal.is_editable_post_deadline:
raise BadRequest("Invalid post data.")
if (value == 'unchecked' and
self.data.proposal.is_editable_post_deadline):
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
def update_modification_perm_txn():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
proposal.is_editable_post_deadline = True
elif value == 'checked':
proposal.is_editable_post_deadline = False
db.put(proposal)
db.run_in_transaction(update_modification_perm_txn)
def post(self):
value = self.data.POST.get('value')
self.toggleModificationPermission(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class AcceptProposal(RequestHandler):
"""View allowing org admins to directly accept the proposal.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/accept/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_accept'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
assert isSet(self.data.proposal_org)
self.check.isOrgAdminForOrganization(self.data.proposal_org)
def toggleStatus(self, value):
"""Toggles the the application state between accept and pending.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and not self.data.proposal.accept_as_project:
raise BadRequest("Invalid post data.")
if value == 'unchecked' and self.data.proposal.accept_as_project:
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
def update_status_txn():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
proposal.accept_as_project = True
elif value == 'checked':
proposal.accept_as_project = False
db.put(proposal)
db.run_in_transaction(update_status_txn)
def post(self):
value = self.data.POST.get('value')
self.toggleStatus(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class ProposalPubliclyVisible(RequestHandler):
"""View allowing the proposer to make the proposal publicly visible.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/publicly_visible/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_publicly_visible'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
self.check.isProposer()
def togglePublicVisibilty(self, value):
"""Toggles the the public visibility of the application.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and not self.data.proposal.is_publicly_visible:
raise BadRequest("Invalid post data.")
if value == 'unchecked' and self.data.proposal.is_publicly_visible:
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
def update_publicly_visibility_txn():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
proposal.is_publicly_visible = True
elif value == 'checked':
proposal.is_publicly_visible = False
db.put(proposal)
db.run_in_transaction(update_publicly_visibility_txn)
def post(self):
value = self.data.POST.get('value')
self.togglePublicVisibilty(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
class WithdrawProposal(RequestHandler):
"""View allowing the proposer to withdraw the proposal.
"""
def djangoURLPatterns(self):
return [
url(r'proposal/withdraw/%s$' % url_patterns.REVIEW,
self, name='gsoc_proposal_withdraw'),
]
def checkAccess(self):
self.mutator.proposalFromKwargs()
self.check.isProposer()
def toggleWithdrawProposal(self, value):
"""Toggles the the application state between withdraw and pending.
Args:
value: can be either "checked" or "unchecked".
"""
assert isSet(self.data.proposal)
if value != 'checked' and value != 'unchecked':
raise BadRequest("Invalid post data.")
if value == 'checked' and not self.data.proposal.status == 'withdrawn':
raise BadRequest("Invalid post data.")
if value == 'unchecked' and self.data.proposal.status == 'withdrawn':
raise BadRequest("Invalid post data.")
proposal_key = self.data.proposal.key()
def update_withdraw_status_txn():
# transactionally get latest version of the proposal
proposal = db.get(proposal_key)
if value == 'unchecked':
proposal.status = 'withdrawn'
elif value == 'checked':
proposal.status = 'pending'
db.put(proposal)
db.run_in_transaction(update_withdraw_status_txn)
def post(self):
value = self.data.POST.get('value')
self.toggleWithdrawProposal(value)
def get(self):
"""Special Handler for HTTP GET request since this view only handles POST.
"""
self.error(405)
| apache-2.0 | -1,911,329,805,116,648,400 | 29.773017 | 79 | 0.666183 | false |
sunfall/giles | giles/games/ataxx/ataxx.py | 1 | 24616 | # Giles: ataxx.py
# Copyright 2012 Phil Bordelon
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from giles.state import State
from giles.games.seated_game import SeatedGame
from giles.games.seat import Seat
from giles.utils import demangle_move
MIN_SIZE = 5
MAX_SIZE = 26
RED = "red"
BLUE = "blue"
YELLOW = "yellow"
GREEN = "green"
PIT = "pit"
COLS = "abcdefghijklmnopqrstuvwxyz"
TAGS = ["abstract", "capture", "square", "2p", "4p"]
class Ataxx(SeatedGame):
"""An Ataxx game table implementation. Invented in 1988 by Dave Crummack
and Craig Galley.
"""
def __init__(self, server, table_name):
super(Ataxx, self).__init__(server, table_name)
self.game_display_name = "Ataxx"
self.game_name = "ataxx"
self.seats = [
Seat("Red"),
Seat("Blue"),
]
self.min_players = 2
self.max_players = 2
self.state = State("need_players")
self.prefix = "(^RAtaxx^~): "
self.log_prefix = "%s/%s: " % (self.table_display_name, self.game_display_name)
# Ataxx-specific stuff.
self.board = None
self.printable_board = None
self.sides = {}
self.size = 7
self.player_mode = 2
self.turn = None
self.last_r = None
self.last_c = None
self.init_seats()
self.init_board()
def init_board(self):
self.board = []
for r in range(self.size):
self.board.append([None] * self.size)
# Place starting pieces, depending on the number of players.
bottom_left = BLUE
bottom_right = RED
if self.player_mode == 4:
bottom_left = YELLOW
bottom_right = GREEN
self.board[0][0] = RED
self.board[0][self.size - 1] = BLUE
self.board[self.size - 1][0] = bottom_left
self.board[self.size - 1][self.size - 1] = bottom_right
self.update_printable_board()
def init_seats(self):
# If we're in 2-player mode, and there are 4 seats, delete the
# extras.
if self.player_mode == 2 and len(self.seats) == 4:
del self.seats[2]
del self.seats[2]
self.sides = {}
# Set the sides and data for players one and two.
self.seats[0].data.side = RED
self.seats[0].data.count = 2
self.seats[0].data.resigned = False
self.seats[1].data.side = BLUE
self.seats[1].data.count = 2
self.seats[1].data.resigned = False
self.sides[RED] = self.seats[0]
self.sides[BLUE] = self.seats[1]
# If there are four players...
if self.player_mode == 4:
# ...and only two seats, create them.
if len(self.seats) == 2:
self.seats.append(Seat("Green"))
self.seats.append(Seat("Yellow"))
# Either way, set the sides and data.
self.seats[2].data.side = GREEN
self.seats[2].data.resigned = False
self.sides[GREEN] = self.seats[2]
self.seats[3].data.side = YELLOW
self.seats[3].data.resigned = False
self.sides[YELLOW] = self.seats[3]
self.seats[0].data.count = 1
self.seats[1].data.count = 1
self.seats[2].data.count = 1
self.seats[3].data.count = 1
def change_player_mode(self, count):
# Don't bother if it's the mode we're already in.
if count == self.player_mode:
return False
# Don't bother if it's not a valid option either.
if count != 2 and count != 4:
return False
# Okay. Set values...
self.player_mode = count
self.min_players = count
self.max_players = count
# ...initialize the seats...
self.init_seats()
# ...and reinitialize the board.
self.init_board()
def update_printable_board(self):
self.printable_board = []
col_str = " " + "".join([" " + COLS[i] for i in range(self.size)])
self.printable_board.append(col_str + "\n")
self.printable_board.append(" ^m.=" + "".join(["=="] * self.size) + ".^~\n")
for r in range(self.size):
this_str = "%2d ^m|^~ " % (r + 1)
for c in range(self.size):
if r == self.last_r and c == self.last_c:
this_str += "^I"
loc = self.board[r][c]
if loc == RED:
this_str += "^RR^~ "
elif loc == BLUE:
this_str += "^BB^~ "
elif loc == GREEN:
this_str += "^GG^~ "
elif loc == YELLOW:
this_str += "^YY^~ "
elif loc == PIT:
this_str += "^Ko^~ "
else:
this_str += "^M.^~ "
this_str += "^m|^~ %d" % (r + 1)
self.printable_board.append(this_str + "\n")
self.printable_board.append(" ^m`=" + "".join(["=="] * self.size) + "'^~\n")
self.printable_board.append(col_str + "\n")
def get_info_str(self):
if not self.turn:
return("The game has not yet started.\n")
if self.turn == RED:
name = self.seats[0].player_name
turn_str = "^RRed^~"
elif self.turn == BLUE:
name = self.seats[1].player_name
turn_str = "^BBlue^~"
elif self.turn == GREEN:
name = self.seats[2].player_name
turn_str = "^GGreen^~"
else:
name = self.seats[3].player_name
turn_str = "^YYellow^~"
info_str = "It is %s's turn (%s).\n" % (name, turn_str)
info_str += "^RRed^~: %d ^BBlue^~: %d" % (self.seats[0].data.count, self.seats[1].data.count)
if self.player_mode == 4:
info_str += " ^GGreen^~: %d ^YYellow^~: %d" % (self.seats[2].data.count, self.seats[3].data.count)
info_str += "\n"
return(info_str)
def show(self, player):
if not self.printable_board:
self.update_printable_board()
for line in self.printable_board:
player.tell_cc(line)
player.tell_cc(self.get_info_str())
def send_board(self):
for listener in self.channel.listeners:
self.show(listener)
def is_valid(self, row, col):
# Note that this does /not/ care about pits, just about the proper
# ranges for coordinates.
if row < 0 or row >= self.size or col < 0 or col >= self.size:
return False
return True
def piece_has_move(self, row, col):
# Returns whether or not a given piece has a potential move.
# Bail on dud data.
if not self.is_valid(row, col) or not self.board[row][col]:
return False
# Okay. A piece can potentially move anywhere in a 5x5 area centered
# on its location.
found_move = False
for r_d in range(-2, 3): # <--- why I hate range syntax.
for c_d in range(-2, 3):
if not found_move and self.is_valid(row + r_d, col + c_d) and not self.board[row + r_d][col + c_d]:
found_move = True
# Return whether we found a move or not.
return found_move
def color_has_move(self, color):
# Returns whether or not a given side has a potential move.
# Bail immediately if green or yellow and we're in 2p mode.
if self.player_mode == 2 and (color == YELLOW or color == GREEN):
return False
# Bail if this player has resigned.
if ((color == RED and self.seats[0].data.resigned) or
(color == BLUE and self.seats[1].data.resigned) or
(color == GREEN and self.seats[2].data.resigned) or
(color == YELLOW and self.seats[3].data.resigned)):
return False
# Okay. Scan the board for pieces...
for r in range(self.size):
for c in range(self.size):
if self.board[r][c] == color and self.piece_has_move(r, c):
return True
# Found no moves. This color has no valid moves.
return False
def loc_to_str(self, row, col):
return "%s%s" % (COLS[col], row + 1)
def move(self, player, src_loc, dst_loc):
seat = self.get_seat_of_player(player)
if not seat:
player.tell_cc(self.prefix + "You can't move; you're not playing!\n")
return False
if self.turn != seat.data.side:
player.tell_cc(self.prefix + "You must wait for your turn to move.\n")
return False
if src_loc == dst_loc:
player.tell_cc(self.prefix + "You can't make a non-move move!\n")
return False
src_c, src_r = src_loc
dst_c, dst_r = dst_loc
if not self.is_valid(src_c, src_r) or not self.is_valid(dst_c, dst_r):
player.tell_cc(self.prefix + "Your move is out of bounds.\n")
return False
src_str = self.loc_to_str(src_r, src_c)
dst_str = self.loc_to_str(dst_r, dst_c)
# Do they have a piece at the source?
color = seat.data.side
if self.board[src_r][src_c] != color:
player.tell_cc(self.prefix + "You don't have a piece at ^C%s^~.\n" % src_str)
return False
# Is the destination within range?
if abs(src_r - dst_r) > 2 or abs(src_c - dst_c) > 2:
player.tell_cc(self.prefix + "That move is too far.\n")
return False
# Is the destination empty?
if self.board[dst_r][dst_c]:
player.tell_cc(self.prefix + "^C%s^~ is already occupied.\n" % dst_str)
return False
# In range, to an empty cell. It's a valid move. Mark it.
self.last_r = dst_r
self.last_c = dst_c
# Now, is it a split or a leap?
if abs(src_r - dst_r) < 2 and abs(src_c - dst_c) < 2:
# Split. Add a new piece, increase the count.
action_str = "^Mgrew^~ into"
self.board[dst_r][dst_c] = color
seat.data.count += 1
else:
# Leap. Move the piece, don't increase the count.
action_str = "^Cjumped^~ to"
self.board[src_r][src_c] = None
self.board[dst_r][dst_c] = color
# Whichever action occurred, check all cells surrounding the
# destination. If they are opponents, transform them.
change_count = 0
change_str = ""
for r_d in range(-1, 2):
for c_d in range(-1, 2):
if self.is_valid(dst_r + r_d, dst_c + c_d):
occupier = self.board[dst_r + r_d][dst_c + c_d]
if occupier and occupier != color and occupier != PIT:
# Another player. Uh oh! Flip it and decrement that
# player's count.
self.board[dst_r + r_d][dst_c + c_d] = color
seat.data.count += 1
self.sides[occupier].data.count -= 1
change_count += 1
if change_count:
change_str = ", ^!converting %d piece" % change_count
if change_count != 1:
change_str += "s"
# Tell everyone what just happened.
self.channel.broadcast_cc(self.prefix + "From ^c%s^~, %s %s ^C%s^~%s^~.\n" % (src_str, player, action_str, dst_str, change_str))
self.update_printable_board()
return True
def toggle_pits(self, player, loc_list):
# Undocumented bonus feature: handles multiple locations, but if
# any of them are invalid, it'll bail halfway through. Useful for
# prepping a particular cool layout with a single cut-and-pasted
# string, though.
for loc in loc_list:
col, row = loc
# Bail if out of bounds.
if not self.is_valid(row, col):
player.tell_cc(self.prefix + "Pit out of bounds.\n")
return
# Bail if a starting piece is there.
thing_there = self.board[row][col]
if thing_there and not (thing_there == PIT):
player.tell_cc(self.prefix + "Cannot put a pit on a starting piece.\n")
return
# Since it's a toggle, figure out what we're toggling to.
if thing_there:
new_thing = None
action_str = "^cremoved^~"
else:
new_thing = PIT
action_str = "^Cadded^~"
# Tentative place the thing.
self.board[row][col] = new_thing
# Does it keep red or blue (which, in a 4p game, is equivalent to
# all four players) from being able to make a move? If so, it's
# invalid. Put the board back the way it was.
if not self.color_has_move(RED) or not self.color_has_move(BLUE):
player.tell_cc(self.prefix + "Players must have a valid move.\n")
self.board[row][col] = thing_there
return
loc_list = [(row, col)]
edge = self.size - 1
# In either mode, we place another pit across the center line,
# but not if that's the same location as the one we just placed
# (on the center line on odd-sized boards).
if (edge - row) != row:
self.board[edge - row][col] = new_thing
loc_list.append((edge - row, col))
# Handle the 4p down-reflection if necessary.
if self.player_mode == 4 and (edge - col) != col:
self.board[edge - row][edge - col] = new_thing
loc_list.append((edge - row, edge - col))
# Handle the 4p right-reflection if necessary.
if self.player_mode == 4 and (edge - col) != col:
self.board[row][edge - col] = new_thing
loc_list.append((row, edge - col))
# Generate the list of locations.
loc_str = ", ".join(["^C%s^~" % self.loc_to_str(x[0], x[1]) for x in loc_list])
# Finally, send the string detailing what just happened.
self.channel.broadcast_cc(self.prefix + "^Y%s^~ has %s a pit at: %s\n" % (player, action_str, loc_str))
self.update_printable_board()
def set_size(self, player, size_bits):
if not size_bits.isdigit():
player.tell_cc(self.prefix + "Invalid size command.\n")
return
size = int(size_bits)
if size < MIN_SIZE or size > MAX_SIZE:
player.tell_cc(self.prefix + "Size must be between %d and %d inclusive.\n" % (MIN_SIZE, MAX_SIZE))
return
# Valid!
self.size = size
self.channel.broadcast_cc(self.prefix + "^R%s^~ has set the board size to ^C%d^~.\n" % (player, size))
self.init_board()
self.update_printable_board()
def set_player_mode(self, player, mode_bits):
if not mode_bits.isdigit():
player.tell_cc(self.prefix + "Invalid player mode command.\n")
return
mode = int(mode_bits)
if mode != 2 and mode != 4:
player.tell_cc(self.prefix + "This game only supports two or four players.\n")
return
elif mode == self.player_mode:
player.tell_cc(self.prefix + "This table is already in that mode.\n")
return
else:
self.change_player_mode(mode)
self.channel.broadcast_cc(self.prefix + "^Y%s^~ has changed the game to ^C%d-player^~ mode.\n" % (player, mode))
def resign(self, player):
seat = self.get_seat_of_player(player)
if not seat:
player.tell_cc(self.prefix + "You can't resign; you're not playing!\n")
return False
if self.turn != seat.data.side:
player.tell_cc(self.prefix + "You must wait for your turn to resign.\n")
return False
if seat.data.resigned:
player.tell_cc(self.prefix + "You've already resigned.\n")
return False
# They've passed the tests and can resign.
seat.data.resigned = True
self.channel.broadcast_cc(self.prefix + "^R%s^~ is resigning from the game.\n" % player)
def tick(self):
# If all seats are full and the game is active, autostart.
active_seats = [x for x in self.seats if x.player]
if (self.state.get() == "need_players" and
len(active_seats) == self.player_mode and self.active):
self.state.set("playing")
send_str = "^RRed^~: %s; ^BBlue^~: %s" % (self.seats[0].player_name, self.seats[1].player_name)
if self.player_mode == 4:
send_str += "; ^GGreen^~: %s; ^YYellow^~: %s" % (self.seats[2].player_name, self.seats[3].player_name)
self.channel.broadcast_cc(self.prefix + send_str + "\n")
self.turn = RED
self.send_board()
def handle(self, player, command_str):
# Handle common commands.
handled = self.handle_common_commands(player, command_str)
if not handled:
state = self.state.get()
command_bits = command_str.split()
primary = command_bits[0].lower()
if state == "setup":
if primary in ("size", "sz",):
if len(command_bits) == 2:
self.set_size(player, command_bits[1])
else:
player.tell_cc(self.prefix + "Invalid size command.\n")
handled = True
elif primary in ("players", "player", "pl",):
if len(command_bits) == 2:
self.set_player_mode(player, command_bits[1])
else:
player.tell_cc(self.prefix + "Invalid player mode command.\n")
handled = True
elif primary in ("pit", "hole",):
loc_list = demangle_move(command_bits[1:])
if loc_list:
self.toggle_pits(player, loc_list)
else:
player.tell_cc(self.prefix + "Invalid pit command.\n")
handled = True
elif primary in ("ready", "done", "r", "d",):
self.channel.broadcast_cc(self.prefix + "The game is now looking for players.\n")
self.state.set("need_players")
handled = True
elif state == "need_players":
if primary in ("config", "setup", "conf",):
self.state.set("setup")
self.channel.broadcast_cc(self.prefix + "^R%s^~ has switched the game to setup mode.\n" % player)
handled = True
elif state == "playing":
made_move = False
if primary in ("move", "play", "mv", "pl",):
move_bits = demangle_move(command_bits[1:])
if move_bits and len(move_bits) == 2:
made_move = self.move(player, move_bits[0], move_bits[1])
else:
player.tell_cc(self.prefix + "Invalid move command.\n")
handled = True
elif primary in ("resign",):
self.resign(player)
made_move = True
handled = True
if made_move:
# Did someone win?
winner = self.find_winner()
if winner:
self.resolve(winner)
self.finish()
else:
# Okay, well, let's see whose turn it is. If it comes
# back around to us, the game is over anyway.
curr_turn = self.turn
done = False
while not done:
if self.turn == RED:
self.turn = BLUE
elif self.turn == BLUE:
# The only tough one; switch depending on mode.
if self.player_mode == 2:
self.turn = RED
else:
self.turn = GREEN
elif self.turn == GREEN:
self.turn = YELLOW
elif self.turn == YELLOW:
self.turn = RED
# Now see if this player even has a move.
if self.color_has_move(self.turn):
done = True
elif self.turn == curr_turn:
# If we've wrapped back around to the current
# turn, no one had a move. Bail as well.
done = True
# Check to see if we're back at the mover.
if curr_turn == self.turn:
# No one had a valid move. Game's over.
self.no_move_resolve()
self.finish()
else:
# Otherwise it's some other player's turn; game on.
self.send_board()
if not handled:
player.tell_cc(self.prefix + "Invalid command.\n")
def find_winner(self):
# Get the list of players that haven't resigned and have at least one
# piece left on the board. If that list is only one long, we have a
# winner. Otherwise, the game continues.
live_players = [x for x in self.seats if not x.data.resigned and x.data.count]
if len(live_players) == 1:
return live_players[0].player_name
else:
return None
def resolve(self, winner):
self.send_board()
self.channel.broadcast_cc(self.prefix + "^C%s^~ wins!\n" % winner)
def no_move_resolve(self):
self.send_board()
# We look at the number of pieces each player has. Highest wins.
high_count = -1
high_list = None
for seat in self.seats:
if seat.data.count > high_count:
high_count = seat.data.count
high_list = ["^C%s^~" % seat.player_name]
elif seat.data.count == high_count:
# Potential tie.
high_list.append("^C%s^~" % seat.player_name)
# If a single player has the highest count, they win; otherwise, tie.
if len(high_list) == 1:
self.channel.broadcast_cc(self.prefix + "%s wins with ^Y%d^~ pieces!\n" % (high_list[0], high_count))
else:
self.channel.broadcast_cc(self.prefix + "These players ^Rtied^~ for first with ^Y%d^~ pieces: %s\n" % (", ".join(high_list)))
def show_help(self, player):
super(Ataxx, self).show_help(player)
player.tell_cc("\nATAXX SETUP PHASE:\n\n")
player.tell_cc(" ^!setup^., ^!config^., ^!conf^. Enter setup phase.\n")
player.tell_cc(" ^!size^. <size>, ^!sz^. Set board to <size>.\n")
player.tell_cc(" ^!players^. 2|4, ^!pl^. Set number of players.\n")
player.tell_cc(" ^!pit^. <ln> Add or remove pit at <ln>.\n")
player.tell_cc(" ^!ready^., ^!done^., ^!r^., ^!d^. End setup phase.\n")
player.tell_cc("\nATAXX PLAY:\n\n")
player.tell_cc(" ^!move^. <ln> <ln2>, ^!mv^. Move from <ln> to <ln2> (letter number).\n")
player.tell_cc(" ^!resign^. Resign.\n")
| agpl-3.0 | 1,148,322,591,392,057,900 | 35.960961 | 137 | 0.510156 | false |
mwil/collision | figs/ber_contour_AsAu/plot_ber_contour_AsAu.py | 1 | 3179 | # Copyright 2013-2014 Matthias Wilhelm
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import argparse
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.cm as cm
mpl.rc_file("../rc/1fig-contour-rc.txt")
from style_ber_contour_AsAu import Style1col
def do_plot(mode, content, wide):
global style
style.apply(mode, content, wide)
data = np.load("data/prr_AsAu_%s%s.npz"%(content, wide))
AU, TAU = np.meshgrid(-data["Au_range_dB"], data["tau_range"])
Zu = data["PRR_U"]
Zs = data["PRR_S"]
assert TAU.shape == AU.shape == Zu.shape, "The inputs TAU, AU, PRR_U must have the same shape for plotting!"
plt.clf()
if mode in ("sync",):
# Plot the inverse power ratio, sync signal is stronger for positive ratios
CSf = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower")
CS2 = plt.contour(CSf, colors = ("r",)*5+("w",), linewidths=(0.75,)*5+(1.0,), origin="lower", hold="on")
else:
CSf = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower")
CS2f = plt.contour(CSf, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 1.0), colors=4*("r",)+("w",), linewidths=(0.75,)*4+(1.0,), origin="lower", hold="on")
#CS2f = plt.contour(TAU, -AU, Zu, levels=(0.9, 1.0), colors=("0.0",), linewidths=(1.0,), origin="lower", hold="on")
if content in ("unif",):
CSu = plt.contourf(TAU, AU, Zu, levels=(0.2, 1.0), hatches=("////",), colors=("0.75",), origin="lower")
CS2 = plt.contour(CSu, levels=(0.2,), colors = ("r",), linewidths=(1.0,), origin="lower", hold="on")
style.annotate(mode, content, wide)
plt.axis([data["tau_range"][0], data["tau_range"][-1], -data["Au_range_dB"][-1], -data["Au_range_dB"][0]])
plt.ylabel(r"Signal power ratio ($\mathrm{SIR}$)", labelpad=2)
plt.xlabel(r"Time offset $\tau$ ($/T$)", labelpad=2)
plt.savefig("pdf/prrc2_%s_%s%s_z.pdf"%(mode, content, wide))
if __name__ == "__main__":
argp = argparse.ArgumentParser()
argp.add_argument("mode", choices=("sync", "usync"), help="Plot from the view of the synchronized or unsynchronized sender")
argp.add_argument("content", choices=("same", "unif"), help="Relation between data content in the two transmitted packets")
argp.add_argument("-w", "--wide", action="store_true", help="Wide interval of time offsets used (-4T to 4T instead of -1.5T to 1.5T)")
args = argp.parse_args()
wide = ("_wide" if args.wide else "")
style = Style1col()
do_plot(args.mode, args.content, wide)
| gpl-3.0 | 5,220,181,277,542,690,000 | 40.828947 | 148 | 0.654923 | false |
sburnett/seattle | custominstallerbuilder/common/logging.py | 1 | 2344 | """
<Program Name>
logging.py
<Started>
December 2010
<Author>
Alex Hanson
<Purpose>
Provides a log_exception() function that can be called in the except portion
of a try...except block to log a formatted traceback to sys.stderr.
For exceptions that were not explicitly caught in a try...except block,
provides an AutoLogger class that serves as Django middleware, calling
log_exception() automatically.
"""
import sys
import traceback
def _indent_string(string, num_spaces):
lines = string.strip(' \n').split('\n')
for line_num, line in enumerate(lines):
lines[line_num] = (num_spaces * ' ') + line
return '\n'.join(lines)
def log_exception(request=None):
"""
<Purpose>
Write details regarding the latest thrown exception to sys.stderr. On a web
server, this should send the information to the server error log.
<Arguments>
request:
An optional HttpRequest object, used for providing additional detail.
<Exceptions>
None. Throwing an exception here would be pretty ironic.
<Side Effects>
None.
<Returns>
None.
"""
# By default, do not indent any messages.
indentation = 0
# Log the URL if a request object was given.
if request is not None:
url = request.build_absolute_uri()
sys.stderr.write('Error while generating ' + url + '\n')
# If a URL is printed, then indent the traceback.
indentation = 2
traceback_string = _indent_string(traceback.format_exc(), indentation)
sys.stderr.write(traceback_string + '\n')
sys.stderr.flush()
class AutoLogger(object):
"""
<Purpose>
If an exception is not explicitly caught somewhere, this class will
write the details to the error log. It is meant to be used Django
middleware.
By default, uncaught exceptions will generate an HTTP 500 error (and a
traceback page if in debug mode), but are seemingly not logged by the web
server. This middleware fixes that by manually printing tracebacks to
sys.stderr.
<Side Effects>
None.
<Example Use>
In the Django settings file (settings_base.py), add the following entry to
the MIDDLEWARE_CLASSES list:
'custominstallerbuilder.common.logging.AutoLogger'
"""
def process_exception(self, request, exception):
log_exception(request)
| mit | -7,317,077,929,695,061,000 | 23.673684 | 79 | 0.689846 | false |
endlessm/chromium-browser | build/android/gyp/dex.py | 1 | 19214 | #!/usr/bin/env python
#
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import argparse
import logging
import os
import re
import shutil
import sys
import tempfile
import zipfile
from util import build_utils
from util import md5_check
from util import zipalign
sys.path.insert(1, os.path.join(os.path.dirname(__file__), os.path.pardir))
import convert_dex_profile
_IGNORE_WARNINGS = (
# A play services library triggers this.
r'Type `libcore.io.Memory` was not found',
# Filter out warnings caused by our fake main dex list used to enable
# multidex on library targets.
# Warning: Application does not contain `Foo` as referenced in main-dex-list
r'does not contain `Foo`',
)
def _ParseArgs(args):
args = build_utils.ExpandFileArgs(args)
parser = argparse.ArgumentParser()
build_utils.AddDepfileOption(parser)
parser.add_argument('--output', required=True, help='Dex output path.')
parser.add_argument(
'--class-inputs',
action='append',
help='GN-list of .jars with .class files.')
parser.add_argument(
'--class-inputs-filearg',
action='append',
help='GN-list of .jars with .class files (added to depfile).')
parser.add_argument(
'--dex-inputs', action='append', help='GN-list of .jars with .dex files.')
parser.add_argument(
'--dex-inputs-filearg',
action='append',
help='GN-list of .jars with .dex files (added to depfile).')
parser.add_argument(
'--incremental-dir',
help='Path of directory to put intermediate dex files.')
parser.add_argument(
'--main-dex-list-path',
help='File containing a list of the classes to include in the main dex.')
parser.add_argument(
'--multi-dex',
action='store_true',
help='Allow multiple dex files within output.')
parser.add_argument('--r8-jar-path', required=True, help='Path to R8 jar.')
parser.add_argument('--desugar', action='store_true')
parser.add_argument(
'--bootclasspath',
action='append',
help='GN-list of bootclasspath. Needed for --desugar')
parser.add_argument(
'--desugar-jdk-libs-json', help='Path to desugar_jdk_libs.json.')
parser.add_argument(
'--classpath',
action='append',
help='GN-list of full classpath. Needed for --desugar')
parser.add_argument(
'--release',
action='store_true',
help='Run D8 in release mode. Release mode maximises main dex and '
'deletes non-essential line number information (vs debug which minimizes '
'main dex and keeps all line number information, and then some.')
parser.add_argument(
'--min-api', help='Minimum Android API level compatibility.')
group = parser.add_argument_group('Dexlayout')
group.add_argument(
'--dexlayout-profile',
help=('Text profile for dexlayout. If present, a dexlayout '
'pass will happen'))
group.add_argument(
'--profman-path',
help=('Path to ART profman binary. There should be a lib/ directory at '
'the same path with shared libraries (shared with dexlayout).'))
group.add_argument(
'--dexlayout-path',
help=('Path to ART dexlayout binary. There should be a lib/ directory at '
'the same path with shared libraries (shared with dexlayout).'))
group.add_argument('--dexdump-path', help='Path to dexdump binary.')
group.add_argument(
'--proguard-mapping-path',
help=('Path to proguard map from obfuscated symbols in the jar to '
'unobfuscated symbols present in the code. If not present, the jar '
'is assumed not to be obfuscated.'))
parser.add_argument(
'--force-enable-assertions',
action='store_true',
help='Forcefully enable javac generated assertion code.')
options = parser.parse_args(args)
if options.dexlayout_profile:
build_utils.CheckOptions(
options,
parser,
required=('profman_path', 'dexlayout_path', 'dexdump_path'))
elif options.proguard_mapping_path is not None:
parser.error('Unexpected proguard mapping without dexlayout')
if options.main_dex_list_path and not options.multi_dex:
parser.error('--main-dex-list-path is unused if multidex is not enabled')
options.class_inputs = build_utils.ParseGnList(options.class_inputs)
options.class_inputs_filearg = build_utils.ParseGnList(
options.class_inputs_filearg)
options.bootclasspath = build_utils.ParseGnList(options.bootclasspath)
options.classpath = build_utils.ParseGnList(options.classpath)
options.dex_inputs = build_utils.ParseGnList(options.dex_inputs)
options.dex_inputs_filearg = build_utils.ParseGnList(
options.dex_inputs_filearg)
return options
def _RunD8(dex_cmd, input_paths, output_path):
dex_cmd = dex_cmd + ['--output', output_path] + input_paths
def stderr_filter(output):
patterns = _IGNORE_WARNINGS
# No classpath means we are using Bazel's Desugar tool to desugar lambdas
# and interface methods, in which case we intentionally do not pass a
# classpath to D8.
# Not having a classpath makes incremental dexing much more effective.
# D8 will still be used for backported method desugaring.
# We still use D8 for backported method desugaring.
if '--classpath' not in dex_cmd:
patterns = list(patterns) + ['default or static interface methods']
combined_pattern = '|'.join(re.escape(p) for p in patterns)
output = build_utils.FilterLines(output, combined_pattern)
# Each warning has a prefix line of tthe file it's from. If we've filtered
# out the warning, then also filter out the file header.
# E.g.:
# Warning in path/to/Foo.class:
# Error message #1 indented here.
# Error message #2 indented here.
output = re.sub(r'^Warning in .*?:\n(?! )', '', output, flags=re.MULTILINE)
return output
# stdout sometimes spams with things like:
# Stripped invalid locals information from 1 method.
build_utils.CheckOutput(dex_cmd, stderr_filter=stderr_filter)
def _EnvWithArtLibPath(binary_path):
"""Return an environment dictionary for ART host shared libraries.
Args:
binary_path: the path to an ART host binary.
Returns:
An environment dictionary where LD_LIBRARY_PATH has been augmented with the
shared library path for the binary. This assumes that there is a lib/
directory in the same location as the binary.
"""
lib_path = os.path.join(os.path.dirname(binary_path), 'lib')
env = os.environ.copy()
libraries = [l for l in env.get('LD_LIBRARY_PATH', '').split(':') if l]
libraries.append(lib_path)
env['LD_LIBRARY_PATH'] = ':'.join(libraries)
return env
def _CreateBinaryProfile(text_profile, input_dex, profman_path, temp_dir):
"""Create a binary profile for dexlayout.
Args:
text_profile: The ART text profile that will be converted to a binary
profile.
input_dex: The input dex file to layout.
profman_path: Path to the profman binary.
temp_dir: Directory to work in.
Returns:
The name of the binary profile, which will live in temp_dir.
"""
binary_profile = os.path.join(
temp_dir, 'binary_profile-for-' + os.path.basename(text_profile))
open(binary_profile, 'w').close() # Touch binary_profile.
profman_cmd = [profman_path,
'--apk=' + input_dex,
'--dex-location=' + input_dex,
'--create-profile-from=' + text_profile,
'--reference-profile-file=' + binary_profile]
build_utils.CheckOutput(
profman_cmd,
env=_EnvWithArtLibPath(profman_path),
stderr_filter=lambda output:
build_utils.FilterLines(output, '|'.join(
[r'Could not find (method_id|proto_id|name):',
r'Could not create type list'])))
return binary_profile
def _LayoutDex(binary_profile, input_dex, dexlayout_path, temp_dir):
"""Layout a dexfile using a profile.
Args:
binary_profile: An ART binary profile, eg output from _CreateBinaryProfile.
input_dex: The dex file used to create the binary profile.
dexlayout_path: Path to the dexlayout binary.
temp_dir: Directory to work in.
Returns:
List of output files produced by dexlayout. This will be one if the input
was a single dexfile, or multiple files if the input was a multidex
zip. These output files are located in temp_dir.
"""
dexlayout_output_dir = os.path.join(temp_dir, 'dexlayout_output')
os.mkdir(dexlayout_output_dir)
dexlayout_cmd = [ dexlayout_path,
'-u', # Update checksum
'-p', binary_profile,
'-w', dexlayout_output_dir,
input_dex ]
build_utils.CheckOutput(
dexlayout_cmd,
env=_EnvWithArtLibPath(dexlayout_path),
stderr_filter=lambda output:
build_utils.FilterLines(output,
r'Can.t mmap dex file.*please zipalign'))
output_files = os.listdir(dexlayout_output_dir)
if not output_files:
raise Exception('dexlayout unexpectedly produced no output')
return sorted([os.path.join(dexlayout_output_dir, f) for f in output_files])
def _ZipMultidex(file_dir, dex_files):
"""Zip dex files into a multidex.
Args:
file_dir: The directory into which to write the output.
dex_files: The dexfiles forming the multizip. Their names must end with
classes.dex, classes2.dex, ...
Returns:
The name of the multidex file, which will live in file_dir.
"""
ordered_files = [] # List of (archive name, file name)
for f in dex_files:
if f.endswith('dex.jar'):
ordered_files.append(('classes.dex', f))
break
if not ordered_files:
raise Exception('Could not find classes.dex multidex file in %s',
dex_files)
for dex_idx in xrange(2, len(dex_files) + 1):
archive_name = 'classes%d.dex' % dex_idx
for f in dex_files:
if f.endswith(archive_name):
ordered_files.append((archive_name, f))
break
else:
raise Exception('Could not find classes%d.dex multidex file in %s',
dex_files)
if len(set(f[1] for f in ordered_files)) != len(ordered_files):
raise Exception('Unexpected clashing filenames for multidex in %s',
dex_files)
zip_name = os.path.join(file_dir, 'multidex_classes.zip')
build_utils.DoZip(((archive_name, os.path.join(file_dir, file_name))
for archive_name, file_name in ordered_files),
zip_name)
return zip_name
def _ZipAligned(dex_files, output_path):
"""Creates a .dex.jar with 4-byte aligned files.
Args:
dex_files: List of dex files.
output_path: The output file in which to write the zip.
"""
with zipfile.ZipFile(output_path, 'w') as z:
for i, dex_file in enumerate(dex_files):
name = 'classes{}.dex'.format(i + 1 if i > 0 else '')
zipalign.AddToZipHermetic(z, name, src_path=dex_file, alignment=4)
def _PerformDexlayout(tmp_dir, tmp_dex_output, options):
if options.proguard_mapping_path is not None:
matching_profile = os.path.join(tmp_dir, 'obfuscated_profile')
convert_dex_profile.ObfuscateProfile(
options.dexlayout_profile, tmp_dex_output,
options.proguard_mapping_path, options.dexdump_path, matching_profile)
else:
logging.warning('No obfuscation for %s', options.dexlayout_profile)
matching_profile = options.dexlayout_profile
binary_profile = _CreateBinaryProfile(matching_profile, tmp_dex_output,
options.profman_path, tmp_dir)
output_files = _LayoutDex(binary_profile, tmp_dex_output,
options.dexlayout_path, tmp_dir)
if len(output_files) > 1:
return _ZipMultidex(tmp_dir, output_files)
if zipfile.is_zipfile(output_files[0]):
return output_files[0]
final_output = os.path.join(tmp_dir, 'dex_classes.zip')
_ZipAligned(output_files, final_output)
return final_output
def _CreateFinalDex(d8_inputs, output, tmp_dir, dex_cmd, options=None):
tmp_dex_output = os.path.join(tmp_dir, 'tmp_dex_output.zip')
if (output.endswith('.dex')
or not all(f.endswith('.dex') for f in d8_inputs)):
if options:
if options.main_dex_list_path:
dex_cmd = dex_cmd + ['--main-dex-list', options.main_dex_list_path]
elif options.multi_dex and int(options.min_api or 1) < 21:
# When dexing library targets, it doesn't matter what's in the main dex.
tmp_main_dex_list_path = os.path.join(tmp_dir, 'main_list.txt')
with open(tmp_main_dex_list_path, 'w') as f:
f.write('Foo.class\n')
dex_cmd = dex_cmd + ['--main-dex-list', tmp_main_dex_list_path]
tmp_dex_dir = os.path.join(tmp_dir, 'tmp_dex_dir')
os.mkdir(tmp_dex_dir)
_RunD8(dex_cmd, d8_inputs, tmp_dex_dir)
logging.debug('Performed dex merging')
dex_files = [os.path.join(tmp_dex_dir, f) for f in os.listdir(tmp_dex_dir)]
if output.endswith('.dex'):
if len(dex_files) > 1:
raise Exception('%d files created, expected 1' % len(dex_files))
tmp_dex_output = dex_files[0]
else:
_ZipAligned(sorted(dex_files), tmp_dex_output)
else:
# Skip dexmerger. Just put all incrementals into the .jar individually.
_ZipAligned(sorted(d8_inputs), tmp_dex_output)
logging.debug('Quick-zipped %d files', len(d8_inputs))
if options and options.dexlayout_profile:
tmp_dex_output = _PerformDexlayout(tmp_dir, tmp_dex_output, options)
# The dex file is complete and can be moved out of tmp_dir.
shutil.move(tmp_dex_output, output)
def _IntermediateDexFilePathsFromInputJars(class_inputs, incremental_dir):
"""Returns a list of all intermediate dex file paths."""
dex_files = []
for jar in class_inputs:
with zipfile.ZipFile(jar, 'r') as z:
for subpath in z.namelist():
if subpath.endswith('.class'):
subpath = subpath[:-5] + 'dex'
dex_files.append(os.path.join(incremental_dir, subpath))
return dex_files
def _DeleteStaleIncrementalDexFiles(dex_dir, dex_files):
"""Deletes intermediate .dex files that are no longer needed."""
all_files = build_utils.FindInDirectory(dex_dir)
desired_files = set(dex_files)
for path in all_files:
if path not in desired_files:
os.unlink(path)
def _ExtractClassFiles(changes, tmp_dir, class_inputs):
classes_list = []
for jar in class_inputs:
if changes:
changed_class_list = set(changes.IterChangedSubpaths(jar))
predicate = lambda x: x in changed_class_list and x.endswith('.class')
else:
predicate = lambda x: x.endswith('.class')
classes_list.extend(
build_utils.ExtractAll(jar, path=tmp_dir, predicate=predicate))
return classes_list
def _CreateIntermediateDexFiles(changes, options, tmp_dir, dex_cmd):
# Create temporary directory for classes to be extracted to.
tmp_extract_dir = os.path.join(tmp_dir, 'tmp_extract_dir')
os.mkdir(tmp_extract_dir)
# Do a full rebuild when changes are to classpath or other non-input files.
allowed_changed = set(options.class_inputs)
allowed_changed.update(options.dex_inputs)
strings_changed = changes.HasStringChanges()
non_direct_input_changed = next(
(p for p in changes.IterChangedPaths() if p not in allowed_changed), None)
if strings_changed or non_direct_input_changed:
logging.debug('Full dex required: strings_changed=%s path_changed=%s',
strings_changed, non_direct_input_changed)
changes = None
class_files = _ExtractClassFiles(changes, tmp_extract_dir,
options.class_inputs)
logging.debug('Extracted class files: %d', len(class_files))
# If the only change is deleting a file, class_files will be empty.
if class_files:
# Dex necessary classes into intermediate dex files.
dex_cmd = dex_cmd + ['--intermediate', '--file-per-class']
_RunD8(dex_cmd, class_files, options.incremental_dir)
logging.debug('Dexed class files.')
def _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd):
logging.debug('_OnStaleMd5')
with build_utils.TempDir() as tmp_dir:
if options.incremental_dir:
# Create directory for all intermediate dex files.
if not os.path.exists(options.incremental_dir):
os.makedirs(options.incremental_dir)
_DeleteStaleIncrementalDexFiles(options.incremental_dir, final_dex_inputs)
logging.debug('Stale files deleted')
_CreateIntermediateDexFiles(changes, options, tmp_dir, dex_cmd)
_CreateFinalDex(
final_dex_inputs, options.output, tmp_dir, dex_cmd, options=options)
def MergeDexForIncrementalInstall(r8_jar_path, src_paths, dest_dex_jar):
dex_cmd = [
build_utils.JAVA_PATH,
'-jar',
r8_jar_path,
'd8',
]
with build_utils.TempDir() as tmp_dir:
_CreateFinalDex(src_paths, dest_dex_jar, tmp_dir, dex_cmd)
def main(args):
build_utils.InitLogging('DEX_DEBUG')
options = _ParseArgs(args)
options.class_inputs += options.class_inputs_filearg
options.dex_inputs += options.dex_inputs_filearg
input_paths = options.class_inputs + options.dex_inputs
if options.multi_dex and options.main_dex_list_path:
input_paths.append(options.main_dex_list_path)
input_paths.append(options.r8_jar_path)
depfile_deps = options.class_inputs_filearg + options.dex_inputs_filearg
output_paths = [options.output]
if options.incremental_dir:
final_dex_inputs = _IntermediateDexFilePathsFromInputJars(
options.class_inputs, options.incremental_dir)
output_paths += final_dex_inputs
track_subpaths_allowlist = options.class_inputs
else:
final_dex_inputs = list(options.class_inputs)
track_subpaths_allowlist = None
final_dex_inputs += options.dex_inputs
dex_cmd = [
build_utils.JAVA_PATH, '-jar', options.r8_jar_path, 'd8',
]
if options.release:
dex_cmd += ['--release']
if options.min_api:
dex_cmd += ['--min-api', options.min_api]
if not options.desugar:
dex_cmd += ['--no-desugaring']
elif options.classpath:
# Don't pass classpath when Desugar.jar is doing interface desugaring.
dex_cmd += ['--lib', build_utils.JAVA_HOME]
for path in options.bootclasspath:
dex_cmd += ['--lib', path]
for path in options.classpath:
dex_cmd += ['--classpath', path]
depfile_deps += options.classpath
depfile_deps += options.bootclasspath
input_paths += options.classpath
input_paths += options.bootclasspath
if options.desugar_jdk_libs_json:
dex_cmd += ['--desugared-lib', options.desugar_jdk_libs_json]
if options.force_enable_assertions:
dex_cmd += ['--force-enable-assertions']
md5_check.CallAndWriteDepfileIfStale(
lambda changes: _OnStaleMd5(changes, options, final_dex_inputs, dex_cmd),
options,
input_paths=input_paths,
input_strings=dex_cmd + [bool(options.incremental_dir)],
output_paths=output_paths,
pass_changes=True,
track_subpaths_allowlist=track_subpaths_allowlist,
depfile_deps=depfile_deps)
if __name__ == '__main__':
sys.exit(main(sys.argv[1:]))
| bsd-3-clause | 7,710,404,384,167,602,000 | 35.95 | 80 | 0.67404 | false |
erigones/esdc-ce | api/authtoken/apps.py | 1 | 1738 | """
Copied+modified from rest_framework.authtoken.apps, which is licensed under the BSD license:
*******************************************************************************
Copyright (c) 2011-2016, Tom Christie
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************
"""
from django.apps import AppConfig
from django.utils.translation import ugettext_lazy as _
class AuthTokenConfig(AppConfig):
name = 'api.authtoken'
verbose_name = _("Auth Token")
| apache-2.0 | 4,715,227,434,735,411,000 | 50.117647 | 92 | 0.732451 | false |
jeremyosborne/python | multiproc/mproc.py | 1 | 2729 | # Why potentially use multiprocessing over threading?
# See:
#
# http://eli.thegreenplace.net/2012/01/16/python-parallelizing-cpu-bound-tasks-with-multiprocessing/
# and
# http://www.dabeaz.com/GIL/
# Notes about multiprocessing: Need to be able to do multiple imports on
# the __main__ file, and as such cannot do these examples from the command
# line.
import multiprocessing
import time
import random
class NamedObject(object):
"""Object identifiable by a name.
"""
def __init__(self, name):
self.name = name
def speak(self):
# arbitrary minor pause.
time.sleep(random.random())
# Processes have names. We can get the name from the multiprocess
# module static method current_process. The name is arbitrary.
proc_name = multiprocessing.current_process().name
print 'My name is {0}, and I am in {1}!'.format(self.name, proc_name)
def worker(q):
while q.empty() is not True:
# Pull an item from the queue.
obj = q.get()
# We assume that we're only getting NamedObjects.
# If we weren't getting named objects, this would break.
obj.speak()
if __name__ == '__main__':
name = "George Foreman %s"
# Queues are First In, First Out objects designed for passing data into
# a process callback.
qs = multiprocessing.Queue(), multiprocessing.Queue()
for i in range(10):
# Fill the qs
qs[i % 2].put(NamedObject(name % i))
# This spawns our secondary process.
# Should always call with keyword arguments.
# target is our callback function
# args {tuple} are passed to our target as formal arguments.
p = multiprocessing.Process(target=worker, args=(qs[0],))
p2 = multiprocessing.Process(target=worker, args=(qs[1],))
# Begin the process.
p.start()
p2.start()
# Attempt to join the background process and flush the queue into it.
# But, if we close, we don't have to purposefully join.
# (This call is not always required, it is implied when we call close and
# the process is not a daemon).
#qs[0].join_thread()
#qs[1].join_thread()
# Wait for the worker to finish
# Close indicates no more data will be added to the queue.
# We need to close the data queue before joining the thread.
qs[0].close()
qs[1].close()
# Pause until the process terminates (blocking call).
# (This call is not required).
#p.join()
#p2.join()
# With the join call, print will not execute until the queue is empty.
# Turn off the p.join() above and print will call before the other procs.
print "If join is called, I will always be last. If not...."
| mit | 5,438,134,134,401,925,000 | 33.1125 | 104 | 0.648223 | false |
pracedru/pyDesign | PyDesignData/PyDesignSerializer.py | 1 | 1563 | import json
import zlib
import base64
import PyDesignData.PyDesignDocument
__author__ = 'magnus'
def complex_handler(Obj):
if hasattr(Obj, 'jsonable'):
return Obj.jsonable()
else:
raise Exception('Object of type %s with value of %s is not JSON serializable' % (type(Obj), repr(Obj)))
def serialize_document_to_console(document):
print(json.dumps(document, default=complex_handler))
def serialize_document_to_disk(document):
data = json.dumps(document, default=complex_handler)
if ".json" in document.name:
text_file = open(document.path + "/" + document.name, "w")
text_file.write(data)
text_file.close()
else:
code = zlib.compress(bytes(data, 'UTF-8'))
text_file = open(document.path + "/" + document.name, "wb")
text_file.write(code)
text_file.close()
document.changed = False
def deserialize_document_from_disk(file_path):
doc = None
if ".json" in file_path:
with open(file_path) as data_file:
data = json.load(data_file)
doc = PyDesignData.PyDesignDocument.PyDesignDocument.deserialize(data)
doc.path = file_path.replace("/" + doc.name, "")
else:
with open(file_path, "rb") as data_file:
S = data_file.read()
data_string = zlib.decompress(S)
data = json.loads(data_string.decode("UTF-8"))
doc = PyDesignData.PyDesignDocument.PyDesignDocument.deserialize(data)
doc.path = file_path.replace("/" + doc.name, "")
return doc
| mit | 1,326,747,839,351,036,200 | 30.26 | 111 | 0.62572 | false |
andreashorn/lead_dbs | ext_libs/OSS-DBS/OSS_platform/Math_module_MPI_only_FEniCS.py | 1 | 25928 | # -*- coding: utf-8 -*-
"""
Created on Sun Aug 19 13:23:54 2018
@author: butenko
"""
from dolfin import *
from pandas import read_csv
from tissue_dielectrics import DielectricProperties
import numpy as np
import os
import subprocess
import pickle
import warnings
warnings.filterwarnings("ignore")
import importlib
# additions
#import CSF_refinement as CSF_imp
import time as tm
#def run_mpi(np):
# print("Code runs in parallel, {} processors.".format(np))
# subprocess.call(["mpirun", "-np", "{}".format(np), "python3", "Math_module_MPI_only_FEniCS.py"])
parameters["allow_extrapolation"]=True
parameters['linear_algebra_backend']='PETSc'
set_log_active(False) #turns off debugging info
#def norm_E(E_r,E_im):
# return sqrt(E_r[0] ** 2 + E_r[1] ** 2+ E_r[2] ** 2+E_im[0] ** 2 + E_im[1] ** 2+ E_im[2] ** 2)
#this function runs in series
#def get_solutions(EQS_form,Domains,boundaries_sol,frequency,el_order): #know where to look for the solutions in h5py files
def get_solutions(EQS_form,frequency,el_order):
start_reassamble=tm.time()
mesh_sol = Mesh()
f = HDF5File(mesh_sol.mpi_comm(),os.environ['PATIENTDIR']+"/Results_adaptive/Solution_"+str(np.round(frequency,6))+".h5",'r')
f.read(mesh_sol,"mesh_sol", False)
if EQS_form == 'EQS':
Er = FiniteElement("Lagrange", mesh_sol.ufl_cell(),el_order)
Ei = FiniteElement("Lagrange", mesh_sol.ufl_cell(),el_order)
Ec = Er * Ei
V = FunctionSpace(mesh_sol, Ec)
phi_sol=Function(V)
f.read(phi_sol,'solution_phi_full')
phi_r_sol,phi_i_sol=phi_sol.split(deepcopy=True)
if el_order>1:
W =VectorFunctionSpace(mesh_sol,'DG',el_order-1)
W_i =VectorFunctionSpace(mesh_sol,'DG',el_order-1)
V_normE=FunctionSpace(mesh_sol,"CG",el_order-1)
else:
W =VectorFunctionSpace(mesh_sol,'DG',el_order)
W_i =VectorFunctionSpace(mesh_sol,'DG',el_order)
V_normE=FunctionSpace(mesh_sol,"CG",el_order)
E_field = Function(W)
E_field_im = Function(W_i)
f.read(E_field,'solution_E_field')
f.read(E_field_im,'solution_E_field_im')
j_dens_real = Function(W)
j_dens_im = Function(W_i)
f.read(j_dens_real, "solution_j_real")
f.read(j_dens_im, "solution_j_im")
J_Vector=PETScVector(MPI.comm_world,2)
f.read(J_Vector, "J_Vector",False)
J_real,J_im=J_Vector[:]
E_norm=project(sqrt(inner(E_field,E_field)+inner(E_field_im,E_field_im)),V_normE,solver_type="cg", preconditioner_type="amg")
max_E=E_norm.vector().max()
file=File(os.environ['PATIENTDIR']+'/Results_adaptive/Phi_r_field_EQS.pvd')
file<<phi_r_sol,mesh_sol
file=File(os.environ['PATIENTDIR']+'/Results_adaptive/Phi_im_field_EQS.pvd')
file<<phi_i_sol,mesh_sol
file=File(os.environ['PATIENTDIR']+'/Results_adaptive/E_norm_EQS.pvd')
file<<E_norm,mesh_sol
elif EQS_form == 'QS':
V = FunctionSpace(mesh_sol, "Lagrange",el_order)
phi_r_sol=Function(V)
phi_i_sol=Function(V)
f.read(phi_r_sol,'solution_phi_full')
phi_i_sol.vector()[:]=0.0
if el_order>1:
W =VectorFunctionSpace(mesh_sol,'DG',el_order-1)
V_normE=FunctionSpace(mesh_sol,"CG",el_order-1)
else:
W =VectorFunctionSpace(mesh_sol,'DG',el_order)
V_normE=FunctionSpace(mesh_sol,"CG",el_order)
E_field = Function(W)
f.read(E_field,'solution_E_field')
E_field_im=Function(W)
E_field_im.vector()[:] = 0.0 #fake
j_dens_real = Function(W)
j_dens_im = Function(W)
f.read(j_dens_real, "solution_j_real")
j_dens_im.vector()[:] = 0.0 #fake
J_Vector=PETScVector(MPI.comm_world,2)
f.read(J_Vector, "J_Vector",False)
J_real,J_im=J_Vector[:]
E_norm=project(sqrt(inner(E_field,E_field)),V_normE,solver_type="cg", preconditioner_type="amg")
max_E=E_norm.vector().max()
file=File(os.environ['PATIENTDIR']+'/Results_adaptive/E_norm_QS.pvd')
file<<E_norm,mesh_sol
file=File(os.environ['PATIENTDIR']+'/Results_adaptive/Phi_r_field_QS.pvd')
file<<phi_r_sol,mesh_sol
f.close()
#if we want to get the potential magnitude on the neuron compartments
Vertices_get=read_csv(os.environ['PATIENTDIR']+'/Neuron_model_arrays/Vert_of_Neural_model_NEURON.csv', delimiter=' ', header=None)
Vertices_array=Vertices_get.values
Phi_ROI=np.zeros((Vertices_array.shape[0],4),float)
for inx in range(Vertices_array.shape[0]):
pnt=Point(Vertices_array[inx,0],Vertices_array[inx,1],Vertices_array[inx,2])
Phi_ROI[inx,0]=Vertices_array[inx,0]
Phi_ROI[inx,1]=Vertices_array[inx,1]
Phi_ROI[inx,2]=Vertices_array[inx,2]
Phi_ROI[inx,3]=np.sqrt(phi_r_sol(pnt)*phi_r_sol(pnt)+phi_i_sol(pnt)*phi_i_sol(pnt))
np.savetxt(os.environ['PATIENTDIR']+'/Results_adaptive/Phi_'+str(frequency)+'.csv', Phi_ROI, delimiter=" ")
if MPI.comm_world.rank==0:
print("Unscaled current on the contact (to check current convergence): ",J_real,J_im)
minutes=int((tm.time() - start_reassamble)/60)
secnds=int(tm.time() - start_reassamble)-minutes*60
print("--- solution reassambled in ",minutes," min ",secnds," s ---")
return phi_r_sol,phi_i_sol,E_field,E_field_im,max_E,J_real,J_im,j_dens_real,j_dens_im
def get_field_on_points(phi_r,phi_i,c_c,J_r,J_i):
#================If we check on predefined vertices===========================#
Vertices_neur_get=read_csv(os.environ['PATIENTDIR']+'/Neuron_model_arrays/Vert_of_Neural_model_NEURON.csv', delimiter=' ', header=None)
Vertices_neur=Vertices_neur_get.values
Ampl_ROI=np.zeros((Vertices_neur.shape[0],4),float)
for inx in range(Vertices_neur.shape[0]):
pnt=Point(Vertices_neur[inx,0],Vertices_neur[inx,1],Vertices_neur[inx,2])
Ampl_ROI[inx,3]=sqrt(phi_r(pnt)*phi_r(pnt)+phi_i(pnt)*phi_i(pnt))
Ampl_ROI[inx,0]=Vertices_neur[inx,0]
Ampl_ROI[inx,1]=Vertices_neur[inx,1]
Ampl_ROI[inx,2]=Vertices_neur[inx,2]
Ampl_ROI=Ampl_ROI[~np.all(Ampl_ROI==0.0,axis=1)] #deletes all zero enteries
return Ampl_ROI
def get_cond_tensor(mesh):
# Code for C++ evaluation of conductivity
conductivity_code = """
#include <pybind11/pybind11.h>
#include <pybind11/eigen.h>
namespace py = pybind11;
#include <dolfin/function/Expression.h>
#include <dolfin/mesh/MeshFunction.h>
class Conductivity : public dolfin::Expression
{
public:
// Create expression with 6 components
Conductivity() : dolfin::Expression(6) {}
// Function for evaluating expression on each cell
void eval(Eigen::Ref<Eigen::VectorXd> values, Eigen::Ref<const Eigen::VectorXd> x, const ufc::cell& cell) const override
{
const uint cell_index = cell.index;
values[0] = (*c00)[cell_index];
values[1] = (*c01)[cell_index];
values[2] = (*c02)[cell_index];
values[3] = (*c11)[cell_index];
values[4] = (*c12)[cell_index];
values[5] = (*c22)[cell_index];
}
// The data stored in mesh functions
std::shared_ptr<dolfin::MeshFunction<double>> c00;
std::shared_ptr<dolfin::MeshFunction<double>> c01;
std::shared_ptr<dolfin::MeshFunction<double>> c02;
std::shared_ptr<dolfin::MeshFunction<double>> c11;
std::shared_ptr<dolfin::MeshFunction<double>> c12;
std::shared_ptr<dolfin::MeshFunction<double>> c22;
};
PYBIND11_MODULE(SIGNATURE, m)
{
py::class_<Conductivity, std::shared_ptr<Conductivity>, dolfin::Expression>
(m, "Conductivity")
.def(py::init<>())
.def_readwrite("c00", &Conductivity::c00)
.def_readwrite("c01", &Conductivity::c01)
.def_readwrite("c02", &Conductivity::c02)
.def_readwrite("c11", &Conductivity::c11)
.def_readwrite("c12", &Conductivity::c12)
.def_readwrite("c22", &Conductivity::c22);
}
"""
# Define conductivity expression and matrix
c00 = MeshFunction("double", mesh, 3, 0.0)
c01 = MeshFunction("double", mesh, 3, 0.0)
c02 = MeshFunction("double", mesh, 3, 0.0)
c11 = MeshFunction("double", mesh, 3, 0.0)
c12 = MeshFunction("double", mesh, 3, 0.0)
c22 = MeshFunction("double", mesh, 3, 0.0)
hdf = HDF5File(mesh.mpi_comm(), os.environ['PATIENTDIR']+"/Results_adaptive/Mesh_to_solve.h5", "r")
hdf.read(c00, "/c00")
hdf.read(c01, "/c01")
hdf.read(c02, "/c02")
hdf.read(c11, "/c11")
hdf.read(c12, "/c12")
hdf.read(c22, "/c22")
hdf.close()
c = CompiledExpression(compile_cpp_code(conductivity_code).Conductivity(),
c00=c00, c01=c01, c02=c02, c11=c11, c12=c12, c22=c22, degree=0)
C = as_matrix(((c[0], c[1], c[2]), (c[1], c[3], c[4]),(c[2],c[4],c[5])))
return C
def compute_field(mesh_sol,Domains,subdomains,boundaries_sol,kappa_r,Field_calc_param,kappa_i=False):
set_log_active(False) #turns off debugging info
if MPI.comm_world.rank==1:
print("_________________________")
parameters['linear_algebra_backend']='PETSc'
if Field_calc_param.EQS_mode == 'EQS':
kappa = [kappa_r, kappa_i]
else:
kappa = [kappa_r]
if Field_calc_param.anisotropy==1:
Cond_tensor=get_cond_tensor(mesh_sol) # unlike get_scaled_cond_tensor, this function does not scale tensor with conductivity (as it was already scaled)
else:
Cond_tensor=False #just to initialize
from Math_module_hybrid import choose_solver_for_me
if Field_calc_param.Solver_type=='Default':
Solver_type=choose_solver_for_me(Field_calc_param.EQS_mode,Domains.Float_contacts) #choses solver basing on the Laplace formulation and whether the floating conductors are used
else:
Solver_type=Field_calc_param.Solver_type # just get the solver directly
#In case of current-controlled stimulation, Dirichlet_bc or the whole potential distribution will be scaled afterwards (due to the system's linearity)
from FEM_in_spectrum import get_solution_space_and_Dirichlet_BC
V_space,Dirichlet_bc,ground_index,facets=get_solution_space_and_Dirichlet_BC(Field_calc_param.external_grounding,Field_calc_param.c_c,mesh_sol,subdomains,boundaries_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,Domains.Contacts,Domains.fi)
#ground index refers to the ground in .med/.msh file
#facets = MeshFunction('size_t',mesh_sol,2)
#facets.set_all(0)
if Field_calc_param.external_grounding==False:
facets.array()[boundaries_sol.array()==Domains.Contacts[ground_index]]=1
dsS=Measure("ds",domain=mesh_sol,subdomain_data=facets)
Ground_surface_size=assemble(1.0*dsS(1))
dx = Measure("dx",domain=mesh_sol)
# to solve the Laplace equation div(kappa*grad(phi))=0 (variational form: a(u,v)=L(v))
start_math=tm.time()
from FEM_in_spectrum import define_variational_form_and_solve
phi_sol=define_variational_form_and_solve(V_space,Dirichlet_bc,kappa,Field_calc_param.EQS_mode,Cond_tensor,Solver_type)
if MPI.comm_world.rank==1:
minutes=int((tm.time() - start_math)/60)
secnds=int(tm.time() - start_math)-minutes*60
print("--- assembled and solved in ",minutes," min ",secnds," s ---")
if Field_calc_param.EQS_mode == 'EQS':
(phi_r_sol,phi_i_sol)=phi_sol.split(deepcopy=True)
else:
phi_r_sol=phi_sol
phi_i_sol=Function(V_space)
phi_i_sol.vector()[:] = 0.0
if MPI.comm_world.rank==1:
print("dofs on 2nd process: ",(max(V_space.dofmap().dofs())+1))
# get current flowing through the grounded contact and the electric field in the whole domain
from FEM_in_spectrum import get_current
J_ground,E_field,E_field_im = get_current(mesh_sol,facets,boundaries_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,Domains.Contacts,kappa,Cond_tensor,phi_r_sol,phi_i_sol,ground_index,get_E_field=True)
# If EQS, J_ground is a complex number. If QS, E_field_im is a null function
# to get current density function which is required for mesh refinement when checking current convergence
from Math_module_hybrid import get_current_density
j_dens_real,j_dens_im = get_current_density(mesh_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,kappa,Cond_tensor,E_field,E_field_im)
# If QS, j_dens_im is null function
# will be used for mesh refinement
j_dens_real_unscaled=j_dens_real.copy(deepcopy=True)
j_dens_im_unscaled=j_dens_im.copy(deepcopy=True) # null function if QS
import copy
J_real_unscaled=copy.deepcopy(np.real(J_ground))
J_im_unscaled=copy.deepcopy(np.imag(J_ground)) # 0 if QS
# to project the E-field magnitude
if Field_calc_param.element_order>1:
V_normE=FunctionSpace(mesh_sol,"CG",Field_calc_param.element_order-1)
else:
V_normE=FunctionSpace(mesh_sol,"CG",Field_calc_param.element_order)
if Field_calc_param.external_grounding==True and (Field_calc_param.c_c==1 or len(Domains.fi)==1):
V_max=max(Domains.fi[:], key=abs)
V_min=0.0
elif -1*Domains.fi[0]==Domains.fi[1]: # V_across is needed only for 2 active contact systems
V_min=-1*abs(Domains.fi[0])
V_max=abs(Domains.fi[0])
else:
V_min=min(Domains.fi[:], key=abs)
V_max=max(Domains.fi[:], key=abs)
V_across=V_max-V_min # this can be negative
### Do not probe anything when inside MPI process!
# Vertices_get=read_csv('Neuron_model_arrays/Vert_of_Neural_model_NEURON.csv', delimiter=' ', header=None)
# Vertices_array=Vertices_get.values
# Phi_ROI=np.zeros((Vertices_array.shape[0],4),float)
#
# for inx in range(Vertices_array.shape[0]):
# pnt=Point(Vertices_array[inx,0],Vertices_array[inx,1],Vertices_array[inx,2])
#
# Phi_ROI[inx,0]=Vertices_array[inx,0]
# Phi_ROI[inx,1]=Vertices_array[inx,1]
# Phi_ROI[inx,2]=Vertices_array[inx,2]
# if Field_calc_param.c_c==1:
# phi_r_sol_scaled_on_point=V_across*np.real((phi_r_sol(pnt)+1j*phi_i_sol(pnt))/(J_real+1j*J_im))
# phi_i_sol_scaled_on_point=V_across*np.imag((phi_r_sol(pnt)+1j*phi_i_sol(pnt))/(J_real+1j*J_im))
# Phi_ROI[inx,3]=np.sqrt(phi_r_sol_scaled_on_point*phi_r_sol_scaled_on_point+phi_i_sol_scaled_on_point*phi_i_sol_scaled_on_point)
# else:
# Phi_ROI[inx,3]=np.sqrt(phi_r_sol(pnt)*phi_r_sol(pnt)+phi_i_sol(pnt)*phi_i_sol(pnt))
#
# np.savetxt('Results_adaptive/Phi_'+str(Field_calc_param.frequenc)+'.csv', Phi_ROI, delimiter=" ")
#save the results
if Field_calc_param.c_c!=1 and Field_calc_param.CPE!=1:
#Just to save total currunt through the ground in FEniCS hdf5
J_Vector=Vector(MPI.comm_self,2)
J_Vector.set_local(np.array([J_real_unscaled,J_im_unscaled],dtype=np.float64))
Hdf=HDF5File(mesh_sol.mpi_comm(), os.environ['PATIENTDIR']+"/Results_adaptive/Solution_"+str(np.round(Field_calc_param.frequenc,6))+".h5", "w")
Hdf.write(mesh_sol, "mesh_sol")
Hdf.write(phi_sol, "solution_phi_full")
Hdf.write(E_field, "solution_E_field")
Hdf.write(E_field_im, "solution_E_field_im")
Hdf.write(j_dens_real_unscaled, "solution_j_real")
Hdf.write(j_dens_im_unscaled, "solution_j_im")
Hdf.write(J_Vector, "/J_Vector")
Hdf.close()
return True
### Do not probe anything when inside MPI process!
# #Probe_of_potential
# probe_z=np.zeros((100,4),float)
# for inx in range(100):
# pnt=Point(75.5,78.5,27.865+inx/10.0)
# probe_z[inx,0]=75.5
# probe_z[inx,1]=78.5
# probe_z[inx,2]=27.865+inx/10.0
# if Field_calc_param.c_c==1:
# phi_r_sol_scaled_on_point=V_across*np.real((phi_r_sol(pnt)+1j*phi_i_sol(pnt))/(J_real+1j*J_im))
# phi_i_sol_scaled_on_point=V_across*np.imag((phi_r_sol(pnt)+1j*phi_i_sol(pnt))/(J_real+1j*J_im))
# probe_z[inx,3]=np.sqrt(phi_r_sol_scaled_on_point*phi_r_sol_scaled_on_point+phi_i_sol_scaled_on_point*phi_i_sol_scaled_on_point)
# else:
# probe_z[inx,3]=np.sqrt(phi_r_sol(pnt)*phi_r_sol(pnt)+phi_i_sol(pnt)*phi_i_sol(pnt))
# np.savetxt('Results_adaptive/Phi_Zprobe'+str(Field_calc_param.frequenc)+'.csv', probe_z, delimiter=" ")
#print("Tissue impedance: ", Z_tis)
#=============================================================================#
if Field_calc_param.c_c==1 or Field_calc_param.CPE==1:
Z_tissue = V_across/J_ground # Tissue impedance
if MPI.comm_world.rank==1:
print("Tissue impedance: ", Z_tissue)
if Field_calc_param.CPE==1:
if len(Domains.fi)>2:
print("Currently, CPE can be used only for simulations with two contacts. Please, assign the rest to 'None'")
raise SystemExit
from GUI_inp_dict import d as d_cpe
CPE_param=[d_cpe["K_A"],d_cpe["beta"],d_cpe["K_A_ground"],d_cpe["beta_ground"]]
from FEM_in_spectrum import get_CPE_corrected_Dirichlet_BC #-1.0 to avoid printing
Dirichlet_bc_with_CPE,total_impedance=get_CPE_corrected_Dirichlet_BC(Field_calc_param.external_grounding,facets,boundaries_sol,CPE_param,Field_calc_param.EQS_mode,Field_calc_param.frequenc,-1.0,Domains.Contacts,Domains.fi,V_across,Z_tissue,V_space)
if MPI.comm_world.rank==1:
print("Solving for an adjusted potential on contacts to account for CPE")
start_math=tm.time()
# to solve the Laplace equation for the adjusted Dirichlet
phi_sol_CPE=define_variational_form_and_solve(V_space,Dirichlet_bc_with_CPE,kappa,Field_calc_param.EQS_mode,Cond_tensor,Solver_type)
if MPI.comm_world.rank==1:
minutes=int((tm.time() - start_math)/60)
secnds=int(tm.time() - start_math)-minutes*60
print("--- assembled and solved in ",minutes," min ",secnds," s ")
if Field_calc_param.EQS_mode=='EQS':
(phi_r_CPE,phi_i_CPE)=phi_sol_CPE.split(deepcopy=True)
else:
phi_r_CPE=phi_sol_CPE
phi_i_CPE=Function(V_space)
phi_i_CPE.vector()[:] = 0.0
# get current flowing through the grounded contact and the electric field in the whole domain
J_ground_CPE,E_field_CPE,E_field_im_CPE = get_current(mesh_sol,facets,boundaries_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,Domains.Contacts,kappa,Cond_tensor,phi_r_CPE,phi_i_CPE,ground_index,get_E_field=True)
# If EQS, J_ground is a complex number. If QS, E_field_CPE is a null function
# to get current density function which is required for mesh refinement when checking current convergence
j_dens_real_CPE,j_dens_im_CPE = get_current_density(mesh_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,kappa,Cond_tensor,E_field_CPE,E_field_im_CPE)
# If QS, j_dens_im is null function
# will be used for mesh refinement
j_dens_real_unscaled=j_dens_real_CPE.copy(deepcopy=True)
j_dens_im_unscaled=j_dens_im_CPE.copy(deepcopy=True)
J_real_unscaled=copy.deepcopy(np.real(J_ground))
J_im_unscaled=copy.deepcopy(np.imag(J_ground))
#Just to save total currunt through the ground in FEniCS hdf5
J_Vector=Vector(MPI.comm_self,2)
J_Vector.set_local(np.array([J_real_unscaled,J_im_unscaled],dtype=np.float64))
Hdf=HDF5File(mesh_sol.mpi_comm(), os.environ['PATIENTDIR']+"/Results_adaptive/Solution_"+str(np.round(Field_calc_param.frequenc,6))+".h5", "w")
Hdf.write(mesh_sol, "mesh_sol")
Hdf.write(phi_sol_CPE, "solution_phi_full")
Hdf.write(E_field_CPE, "solution_E_field")
Hdf.write(E_field_im_CPE, "solution_E_field_im")
Hdf.write(j_dens_real_unscaled, "solution_j_real")
Hdf.write(j_dens_im_unscaled, "solution_j_im")
Hdf.write(J_Vector, "/J_Vector")
Hdf.close()
return True
if Field_calc_param.c_c==1:
if Field_calc_param.EQS_mode=='EQS': # For EQS, we need to scale the potential on boundaries (because the error is absolute) and recompute field, etc. Maybe we can scale them also directly?
Dirichlet_bc_scaled=[]
for bc_i in range(len(Domains.Contacts)): #CPE estimation is valid only for one activa and one ground contact configuration
if Field_calc_param.EQS_mode=='EQS':
if Domains.fi[bc_i]!=0.0:
Active_with_CC=V_across*V_across/J_ground #(impedance * current through the contact (V_across coincides with the assigned current magnitude))
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(0), np.real(Active_with_CC), boundaries_sol,Domains.Contacts[bc_i]))
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(1), np.imag(Active_with_CC), boundaries_sol,Domains.Contacts[bc_i]))
else:
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(0), Constant(0.0), boundaries_sol,Domains.Contacts[bc_i]))
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(1), Constant(0.0), boundaries_sol,Domains.Contacts[bc_i]))
if Field_calc_param.external_grounding==True:
if Sim_setup.Laplace_eq == 'EQS':
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(0),0.0,facets,1))
Dirichlet_bc_scaled.append(DirichletBC(V_space.sub(1),0.0,facets,1))
else:
Dirichlet_bc_scaled.append(DirichletBC(V_space,0.0,facets,1))
print("Solving for a scaled potential on contacts (to match the desired current)")
start_math=tm.time()
# to solve the Laplace equation for the adjusted Dirichlet
phi_sol_scaled=define_variational_form_and_solve(V_space,Dirichlet_bc_scaled,kappa,Field_calc_param.EQS_mode,Cond_tensor,Solver_type)
minutes=int((tm.time() - start_math)/60)
secnds=int(tm.time() - start_math)-minutes*60
print("--- assembled and solved in ",minutes," min ",secnds," s ---")
(phi_r_sol_scaled,phi_i_sol_scaled)=phi_sol_scaled.split(deepcopy=True)
# get current flowing through the grounded contact and the electric field in the whole domain
J_ground_scaled,E_field_scaled,E_field_im_scaled = get_current(mesh_sol,facets,boundaries_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,Domains.Contacts,kappa,Cond_tensor,phi_r_CPE,phi_i_CPE,ground_index,get_E_field=True)
# If EQS, J_ground is a complex number. If QS, E_field_im is 0
else: # here we can simply scale the potential in the domain and recompute the E-field
phi_r_sol_scaled=Function(V_space)
phi_i_sol_scaled=Function(V_space)
phi_i_sol_scaled.vector()[:] = 0.0
phi_r_sol_scaled.vector()[:]=V_across*phi_r_sol.vector()[:]/J_ground
phi_sol_scaled=phi_r_sol_scaled
J_ground_scaled,E_field_scaled,E_field_im_scaled = get_current(mesh_sol,facets,boundaries_sol,Field_calc_param.element_order,Field_calc_param.EQS_mode,Domains.Contacts,kappa,Cond_tensor,phi_r_sol_scaled,phi_i_sol_scaled,ground_index,get_E_field=True)
#E_field_im_scale is a null function
#Just to save total currunt through the ground in FEniCS hdf5 (we save unscaled currents!)
J_Vector=Vector(MPI.comm_self,2)
J_Vector.set_local(np.array([J_real_unscaled,J_im_unscaled],dtype=np.float64))
Hdf=HDF5File(mesh_sol.mpi_comm(), os.environ['PATIENTDIR']+"/Results_adaptive/Solution_"+str(np.round(Field_calc_param.frequenc,6))+".h5", "w")
Hdf.write(mesh_sol, "mesh_sol")
Hdf.write(phi_sol_scaled, "solution_phi_full")
Hdf.write(E_field_scaled, "solution_E_field")
Hdf.write(E_field_im_scaled, "solution_E_field_im")
Hdf.write(j_dens_real_unscaled, "solution_j_real")
Hdf.write(j_dens_im_unscaled, "solution_j_im")
Hdf.write(J_Vector, "/J_Vector")
Hdf.close()
return True
return True
if __name__ == '__main__':
with open(os.environ['PATIENTDIR']+'/Meshes/Mesh_ind.file', "rb") as f:
Domains = pickle.load(f)
with open(os.environ['PATIENTDIR']+'/Results_adaptive/Field_calc_param.file', "rb") as f:
Field_calc_param = pickle.load(f)
mesh = Mesh()
hdf = HDF5File(mesh.mpi_comm(), os.environ['PATIENTDIR']+"/Results_adaptive/Mesh_to_solve.h5", "r")
hdf.read(mesh, "/mesh", False)
subdomains = MeshFunction("size_t", mesh, 3)
hdf.read(subdomains, "/subdomains")
boundaries = MeshFunction("size_t", mesh, 2)
hdf.read(boundaries, "/boundaries")
V0_r=FunctionSpace(mesh,'DG',0)
V0_i=FunctionSpace(mesh,'DG',0)
kappa_r=Function(V0_r)
kappa_i=Function(V0_i)
hdf.read(kappa_r, "/kappa_r")
if Field_calc_param.EQS_mode=='EQS':
hdf.read(kappa_i, "/kappa_i")
#anisotropy will be read in at the site
hdf.close()
if Field_calc_param.EQS_mode=='EQS':
compute_field(mesh,Domains,subdomains,boundaries,kappa_r,Field_calc_param,kappa_i)
elif Field_calc_param.EQS_mode=='QS':
compute_field(mesh,Domains,subdomains,boundaries,kappa_r,Field_calc_param)
| gpl-3.0 | 2,766,105,423,233,284,600 | 45.382826 | 266 | 0.627314 | false |
avinassh/haxor | hackernews/__init__.py | 1 | 13996 | #!/usr/bin/env python
"""
haxor
Unofficial Python wrapper for official Hacker News API
@author avinash sajjanshetty
@email [email protected]
"""
from __future__ import absolute_import
from __future__ import unicode_literals
import asyncio
import datetime
import json
import sys
from urllib.parse import urljoin
import requests
import aiohttp
from .settings import supported_api_versions
__all__ = [
'User',
'Item',
'HackerNews',
'HackerNewsError',
'InvalidAPIVersion',
'InvalidItemID',
'InvalidUserID']
class HackerNewsError(Exception):
pass
class InvalidItemID(HackerNewsError):
pass
class InvalidUserID(HackerNewsError):
pass
class InvalidAPIVersion(HackerNewsError):
pass
class HTTPError(HackerNewsError):
pass
class HackerNews(object):
def __init__(self, version='v0'):
"""
Args:
version (string): specifies Hacker News API version.
Default is `v0`.
Raises:
InvalidAPIVersion: If Hacker News version is not supported.
"""
try:
self.base_url = supported_api_versions[version]
except KeyError:
raise InvalidAPIVersion
self.item_url = urljoin(self.base_url, 'item/')
self.user_url = urljoin(self.base_url, 'user/')
self.session = requests.Session()
def _get_sync(self, url):
"""Internal method used for GET requests
Args:
url (str): URL to fetch
Returns:
Individual URL request's response
Raises:
HTTPError: If HTTP request failed.
"""
response = self.session.get(url)
if response.status_code == requests.codes.ok:
return response.json()
else:
raise HTTPError
async def _get_async(self, url, session):
"""Asynchronous internal method used for GET requests
Args:
url (str): URL to fetch
session (obj): aiohttp client session for async loop
Returns:
data (obj): Individual URL request's response corountine
"""
data = None
async with session.get(url) as resp:
if resp.status == 200:
data = await resp.json()
return data
async def _async_loop(self, urls):
"""Asynchronous internal method used to request multiple URLs
Args:
urls (list): URLs to fetch
Returns:
responses (obj): All URL requests' response coroutines
"""
results = []
async with aiohttp.ClientSession(
connector=aiohttp.TCPConnector(ssl=False)
) as session:
for url in urls:
result = asyncio.ensure_future(self._get_async(url, session))
results.append(result)
responses = await asyncio.gather(*results)
return responses
def _run_async(self, urls):
"""Asynchronous event loop execution
Args:
urls (list): URLs to fetch
Returns:
results (obj): All URL requests' responses
"""
loop = asyncio.get_event_loop()
results = loop.run_until_complete(self._async_loop(urls))
return results
def _get_stories(self, page, limit):
"""
Hacker News has different categories (i.e. stories) like
'topstories', 'newstories', 'askstories', 'showstories', 'jobstories'.
This method, first fetches the relevant story ids of that category
The URL is: https://hacker-news.firebaseio.com/v0/<story_name>.json
e.g. https://hacker-news.firebaseio.com/v0/topstories.json
Then, asynchronously it fetches each story and returns the Item objects
The URL for individual story is:
https://hacker-news.firebaseio.com/v0/item/<item_id>.json
e.g. https://hacker-news.firebaseio.com/v0/item/69696969.json
"""
url = urljoin(self.base_url, F"{page}.json")
story_ids = self._get_sync(url)[:limit]
return self.get_items_by_ids(item_ids=story_ids)
def get_item(self, item_id, expand=False):
"""Returns Hacker News `Item` object.
Fetches the data from url:
https://hacker-news.firebaseio.com/v0/item/<item_id>.json
e.g. https://hacker-news.firebaseio.com/v0/item/69696969.json
Args:
item_id (int or string): Unique item id of Hacker News story,
comment etc.
expand (bool): expand (bool): Flag to indicate whether to
transform all IDs into objects.
Returns:
`Item` object representing Hacker News item.
Raises:
InvalidItemID: If corresponding Hacker News story does not exist.
"""
url = urljoin(self.item_url, F"{item_id}.json")
response = self._get_sync(url)
if not response:
raise InvalidItemID
item = Item(response)
if expand:
item.by = self.get_user(item.by)
item.kids = self.get_items_by_ids(item.kids) if item.kids else None
item.parent = self.get_item(item.parent) if item.parent else None
item.poll = self.get_item(item.poll) if item.poll else None
item.parts = (
self.get_items_by_ids(item.parts) if item.parts else None
)
return item
def get_items_by_ids(self, item_ids, item_type=None):
"""Given a list of item ids, return all the Item objects
Args:
item_ids (obj): List of item IDs to query
item_type (str): (optional) Item type to filter results with
Returns:
List of `Item` objects for given item IDs and given item type
"""
urls = [urljoin(self.item_url, F"{i}.json") for i in item_ids]
result = self._run_async(urls=urls)
items = [Item(r) for r in result if r]
if item_type:
return [item for item in items if item.item_type == item_type]
else:
return items
def get_user(self, user_id, expand=False):
"""Returns Hacker News `User` object.
Fetches data from the url:
https://hacker-news.firebaseio.com/v0/user/<user_id>.json
e.g. https://hacker-news.firebaseio.com/v0/user/pg.json
Args:
user_id (string): unique user id of a Hacker News user.
expand (bool): Flag to indicate whether to
transform all IDs into objects.
Returns:
`User` object representing a user on Hacker News.
Raises:
InvalidUserID: If no such user exists on Hacker News.
"""
url = urljoin(self.user_url, F"{user_id}.json")
response = self._get_sync(url)
if not response:
raise InvalidUserID
user = User(response)
if expand and user.submitted:
items = self.get_items_by_ids(user.submitted)
user_opt = {
'stories': 'story',
'comments': 'comment',
'jobs': 'job',
'polls': 'poll',
'pollopts': 'pollopt'
}
for key, value in user_opt.items():
setattr(
user,
key,
[i for i in items if i.item_type == value]
)
return user
def get_users_by_ids(self, user_ids):
"""
Given a list of user ids, return all the User objects
"""
urls = [urljoin(self.user_url, F"{i}.json") for i in user_ids]
result = self._run_async(urls=urls)
return [User(r) for r in result if r]
def top_stories(self, raw=False, limit=None):
"""Returns list of item ids of current top stories
Args:
limit (int): specifies the number of stories to be returned.
raw (bool): Flag to indicate whether to represent all
objects in raw json.
Returns:
`list` object containing ids of top stories.
"""
top_stories = self._get_stories('topstories', limit)
if raw:
top_stories = [story.raw for story in top_stories]
return top_stories
def new_stories(self, raw=False, limit=None):
"""Returns list of item ids of current new stories
Args:
limit (int): specifies the number of stories to be returned.
raw (bool): Flag to indicate whether to transform all
objects into raw json.
Returns:
`list` object containing ids of new stories.
"""
new_stories = self._get_stories('newstories', limit)
if raw:
new_stories = [story.raw for story in new_stories]
return new_stories
def ask_stories(self, raw=False, limit=None):
"""Returns list of item ids of latest Ask HN stories
Args:
limit (int): specifies the number of stories to be returned.
raw (bool): Flag to indicate whether to transform all
objects into raw json.
Returns:
`list` object containing ids of Ask HN stories.
"""
ask_stories = self._get_stories('askstories', limit)
if raw:
ask_stories = [story.raw for story in ask_stories]
return ask_stories
def show_stories(self, raw=False, limit=None):
"""Returns list of item ids of latest Show HN stories
Args:
limit (int): specifies the number of stories to be returned.
raw (bool): Flag to indicate whether to transform all
objects into raw json.
Returns:
`list` object containing ids of Show HN stories.
"""
show_stories = self._get_stories('showstories', limit)
if raw:
show_stories = [story.raw for story in show_stories]
return show_stories
def job_stories(self, raw=False, limit=None):
"""Returns list of item ids of latest Job stories
Args:
limit (int): specifies the number of stories to be returned.
raw (bool): Flag to indicate whether to transform all
objects into raw json.
Returns:
`list` object containing ids of Job stories.
"""
job_stories = self._get_stories('jobstories', limit)
if raw:
job_stories = [story.raw for story in job_stories]
return job_stories
def updates(self):
"""Returns list of item ids and user ids that have been
changed/updated recently.
Fetches data from URL:
https://hacker-news.firebaseio.com/v0/updates.json
Returns:
`dict` with two keys whose values are `list` objects
"""
url = urljoin(self.base_url, 'updates.json')
response = self._get_sync(url)
return {
'items': self.get_items_by_ids(item_ids=response['items']),
'profiles': self.get_users_by_ids(user_ids=response['profiles'])
}
def get_max_item(self, expand=False):
"""The current largest item id
Fetches data from URL:
https://hacker-news.firebaseio.com/v0/maxitem.json
Args:
expand (bool): Flag to indicate whether to transform all
IDs into objects.
Returns:
`int` if successful.
"""
url = urljoin(self.base_url, 'maxitem.json')
response = self._get_sync(url)
if expand:
return self.get_item(response)
else:
return response
def get_all(self):
"""Returns ENTIRE Hacker News!
Downloads all the HN articles and returns them as Item objects
Returns:
`list` object containing ids of HN stories.
"""
max_item = self.get_max_item()
return self.get_last(num=max_item)
def get_last(self, num=10):
"""Returns last `num` of HN stories
Downloads all the HN articles and returns them as Item objects
Returns:
`list` object containing ids of HN stories.
"""
max_item = self.get_max_item()
urls = [urljoin(self.item_url, F"{i}.json") for i in range(
max_item - num + 1, max_item + 1)]
result = self._run_async(urls=urls)
return [Item(r) for r in result if r]
class Item(object):
"""
Represents stories, comments, jobs, Ask HNs and polls
"""
def __init__(self, data):
self.item_id = data.get('id')
self.deleted = data.get('deleted')
self.item_type = data.get('type')
self.by = data.get('by')
self.submission_time = datetime.datetime.fromtimestamp(
data.get('time', 0))
self.text = data.get('text')
self.dead = data.get('dead')
self.parent = data.get('parent')
self.poll = data.get('poll')
self.kids = data.get('kids')
self.url = data.get('url')
self.score = data.get('score')
self.title = data.get('title')
self.parts = data.get('parts')
self.descendants = data.get('descendants')
self.time = datetime.datetime.fromtimestamp(data.get('time'))
self.raw = json.dumps(data)
def __repr__(self):
retval = '<hackernews.Item: {0} - {1}>'.format(
self.item_id, self.title)
return retval
class User(object):
"""
Represents a hacker i.e. a user on Hacker News
"""
def __init__(self, data):
self.user_id = data.get('id')
self.delay = data.get('delay')
self.created = datetime.datetime.fromtimestamp(data.get('created', 0))
self.karma = data.get('karma')
self.about = data.get('about')
self.submitted = data.get('submitted')
self.raw = json.dumps(data)
def __repr__(self):
retval = '<hackernews.User: {0}>'.format(self.user_id)
return retval
| mit | 7,675,574,859,662,946,000 | 28.341719 | 79 | 0.57345 | false |
geobricks/geobricks_modis | geobricks_modis_test/rest/test_modis_rest.py | 1 | 2136 | import json
import unittest
from flask import Flask
from geobricks_modis.rest.modis_rest import modis
class GeobricksModisRestTest(unittest.TestCase):
def setUp(self):
self.app = Flask(__name__)
self.app.register_blueprint(modis, url_prefix='/modis')
self.tester = self.app.test_client(self)
def test_discovery(self):
response = self.tester.get('/modis/discovery/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(out['title'], 'MODIS')
self.assertEquals(out['properties']['service_type']['default'], 'DATASOURCE')
def test_list_products_service(self):
response = self.tester.get('/modis/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 68)
def test_list_years_service(self):
response = self.tester.get('/modis/MOD13A2/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 16)
def test_list_days_service(self):
response = self.tester.get('/modis/MOD13A2/2014/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 23)
def test_list_layers_service(self):
response = self.tester.get('/modis/MOD13A2/2014/001/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 286)
def test_list_layers_subset_service(self):
response = self.tester.get('/modis/MOD13A2/2014/001/5/7/3/9/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 5)
def test_list_layers_countries_subset_service(self):
response = self.tester.get('/modis/MOD13A2/2014/001/8,IT,fra/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 12)
def test_list_countries(self):
response = self.tester.get('/modis/countries/', content_type='application/json')
out = json.loads(response.data)
self.assertEquals(len(out), 277)
| gpl-2.0 | -8,529,286,641,541,722,000 | 39.301887 | 104 | 0.661985 | false |
combatopera/pym2149 | pym2149/dac.py | 1 | 3553 | # Copyright 2014, 2018, 2019, 2020 Andrzej Cichocki
# This file is part of pym2149.
#
# pym2149 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.
#
# pym2149 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 pym2149. If not, see <http://www.gnu.org/licenses/>.
from .buf import BufType
from .nod import BufNode
from .shapes import level4to5, level5toamp, level4tosinus5shape, level4totone5shape
from diapyr.util import singleton
import numpy as np
class Level(BufNode):
def __init__(self, levelmodereg, fixedreg, env, signal, rtone, timereffectreg):
super().__init__(BufType.signal) # Must be suitable for use as index downstream.
self.levelmodereg = levelmodereg
self.fixedreg = fixedreg
self.env = env
self.signal = signal
self.rtone = rtone
self.timereffectreg = timereffectreg
def callimpl(self):
self.timereffectreg.value.putlevel5(self)
@singleton
class NullEffect:
'All registers are non-virtual and write directly to chip, the timer does not interfere.'
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.signal))
if node.levelmodereg.value:
node.blockbuf.mulbuf(node.chain(node.env))
else:
# According to block diagram, the level is already 5-bit when combining with binary signal:
node.blockbuf.mul(level4to5(node.fixedreg.value))
class FixedLevelEffect:
'Registers levelmodereg and fixedreg are virtual, of which levelmodereg is ignored.'
def __init__(self):
self.wavelength, = {shape.wavelength() for shape in self.level4toshape}
def getshape(self, fixedreg):
return self.level4toshape[fixedreg.value]
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.signal))
node.blockbuf.mulbuf(node.chain(node.rtone))
@singleton
class PWMEffect(FixedLevelEffect):
'Interrupt setup/routine alternates fixed level between fixedreg and zero.'
level4toshape = level4totone5shape
@singleton
class SinusEffect(FixedLevelEffect):
'Interrupt setup/routine sets fixed level to sample value as scaled by fixedreg.'
level4toshape = level4tosinus5shape
class DigiDrumEffect:
'Like SinusEffect but in addition toneflagreg and noiseflagreg are virtual and we ignore them.'
def __init__(self, sample5shape):
self.sample5shape = sample5shape
def getshape(self, fixedreg):
return self.sample5shape
def putlevel5(self, node):
node.blockbuf.copybuf(node.chain(node.rtone))
class Dac(BufNode):
def __init__(self, level, log2maxpeaktopeak, ampshare):
buftype = BufType.float
super().__init__(buftype)
# We take off .5 so that the peak amplitude is about -3 dB:
maxpeaktopeak = (2 ** (log2maxpeaktopeak - .5)) / ampshare
# Lookup of ideal amplitudes:
self.leveltopeaktopeak = np.fromiter((level5toamp(v) * maxpeaktopeak for v in range(32)), buftype.dtype)
self.level = level
def callimpl(self):
self.blockbuf.mapbuf(self.chain(self.level), self.leveltopeaktopeak)
| gpl-3.0 | 8,010,350,940,594,868,000 | 34.888889 | 112 | 0.710667 | false |
Pexego/PXGO_00019_2014_BU | project-addons/sale_shipping_except/__openerp__.py | 1 | 1210 | # -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (C) 2014 Pexego All Rights Reserved
# $Jesús Ventosinos Mayor <[email protected]>$
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
{
'name': "Manage sale shipping exception editable",
'version': '1.0',
'category': '',
'description': """""",
'author': 'Pexego',
'website': '',
"depends": ['sale'],
"data": [],
"installable": True
}
| agpl-3.0 | 7,370,873,289,079,417,000 | 36.78125 | 78 | 0.578991 | false |
Lucas-Wong/ToolsProject | WeChat/AutoWeChat.py | 1 | 1366 | #! /usr/bin/env python
#_*_coding:utf-8_*_
import itchat, time
from itchat.content import *
@itchat.msg_register([TEXT, MAP, CARD, NOTE, SHARING])
def text_reply(msg):
#itchat.send('%s: %s' % (msg['Type'], msg['Text']), msg['FromUserName'])
itchat.send_msg('已经收到了消息，消息内容为%s' % msg['Text'], toUserName=msg['FromUserName'])
return "T reveived: %s" % msg["Text"] # 返回的给对方的消息，msg["Text"]表示消息的内容
@itchat.msg_register([PICTURE, RECORDING, ATTACHMENT, VIDEO])
def download_files(msg):
msg['Text'](msg['FileName'])
return '@%s@%s' % ({'Picture': 'img', 'Video': 'vid'}.get(msg['Type'], 'fil'), msg['FileName'])
@itchat.msg_register(FRIENDS)
def add_friend(msg):
itchat.add_friend(**msg['Text']) # 该操作会自动将新好友的消息录入，不需要重载通讯录
itchat.send_msg('Nice to meet you!', msg['RecommendInfo']['UserName'])
@itchat.msg_register(TEXT, isGroupChat=True)
def text_reply(msg):
if msg['isAt']:
#itchat.send(u'@%s\u2005I received: %s' % (msg['ActualNickName'], msg['Content']), msg['FromUserName'])
itchat.send_msg("我已经收到了来自{0}的消息，实际内容为{1}".format(msg['ActualNickName'], msg['Text']),
toUserName=msg['FromUserName'])
itchat.auto_login(True, hotReload=True)
itchat.run(True) | gpl-3.0 | -4,828,230,460,930,350,000 | 38.516129 | 111 | 0.647059 | false |
NiclasEriksen/py-towerwars | src/test.py | 1 | 5993 | import unittest
# import main
import functions
tcase = unittest.TestCase
class TestColorCodeConverter(tcase):
def test_white(self):
self.assertEqual(functions.get_color(255, 255, 255, 255), (1, 1, 1, 1))
def test_red(self):
self.assertEqual(functions.get_color(255, 0, 0, 255), (1, 0, 0, 1))
def test_green(self):
self.assertEqual(functions.get_color(0, 255, 0, 255), (0, 1, 0, 1))
def test_blue(self):
self.assertEqual(functions.get_color(0, 0, 255, 255), (0, 0, 1, 1))
def test_transparent(self):
self.assertEqual(
functions.get_color(127, 84, 221, 70),
(
0.4980392156862745,
0.32941176470588235,
0.8666666666666667,
0.27450980392156865
)
)
class TestCreateRectangle(tcase):
def test_square(self):
self.assertEqual(
functions.create_rectangle(
48, 48, 32, 32, centered=False
),
[16, 48, 16, 16, 48, 16, 48, 48]
)
def test_rectangle(self):
self.assertEqual(
functions.create_rectangle(
48, 48, 64, 32, centered=False
),
[-16, 48, -16, 16, 48, 16, 48, 48]
)
def test_square_centered(self):
self.assertEqual(
functions.create_rectangle(
48, 48, 32, 32, centered=True
),
[32, 32, 32, 64, 64, 64, 64, 32],
)
def test_rectangle_centered(self):
self.assertEqual(
functions.create_rectangle(
48, 48, 64, 32, centered=True
),
[16, 32, 16, 64, 80, 64, 80, 32]
)
class TestCheckPointInRectangle(tcase):
def test_inside(self):
rect = [32, 32, 32, 64, 64, 64, 64, 32]
self.assertTrue(functions.check_point_rectangle(32, 32, rect))
def test_outside(self):
rect = [32, 32, 32, 64, 64, 64, 64, 32]
self.assertFalse(functions.check_point_rectangle(63, 65, rect))
class Mob:
"""The main mob constructor, for testing"""
def __init__(self, game):
self.move_type = "normal"
self.g = game
self.hp = 14.0
self.spd = 1.0
self.debug = game.debug
self.id = 0
s = game.grid.start
self.x = 0
self.y = 0
self.rx = 0
self.ry = 0 # Real position, which is used in game logic
self.state = "alive"
self.slow_cd = None
self.lastpoint = None
self.stall_timer = None
self.debuff_list = []
self.currentpoint = s
self.point = 0
self.path = False
if self.move_type == "flying":
self.path = game.grid.getPath(self.currentpoint, flying=True)
if not self.path:
self.path = game.grid.path
try:
self.targetpoint = self.path[1]
except IndexError:
self.targetpoint = (0, 0)
def make_game_object(self):
from grid import Grid
self.debug = False
self.grid_dim = (8, 8)
self.spawn = (0, 0)
self.goal = (8, 8)
self.tiles_no_walk = [(4, 4), (4, 5), (5, 5), (5, 6), (6, 6)]
self.tiles_no_build = [(4, 4), (4, 5), (5, 5), (5, 6), (6, 6)]
self.flightgrid = []
self.towers = []
self.grid = Grid(self)
self.grid.update("update")
self.m = Mob(self)
class TestPathChecking(tcase):
def test_update(self):
make_game_object(self)
self.assertTrue(
functions.check_path(self.m, self.grid, (4, 4))
)
def test_not_update(self):
make_game_object(self)
self.assertFalse(
functions.check_path(self.m, self.grid, (4, 5))
)
class TestCheckDiagonal(tcase):
def test_w_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_diagonal(self.grid.w_grid, 3, 3),
[(4, 2), (2, 4), (2, 2)]
)
def test_t_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_diagonal(self.grid.t_grid, 3, 3),
[(4, 2), (2, 4), (2, 2)]
)
def test_full_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_diagonal(self.grid.fullgrid, 3, 3),
[(4, 4), (4, 2), (2, 4), (2, 2)]
)
class TestGetNeighbors(tcase):
def test_w_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_neighbors(self.grid.w_grid, 3, 3),
[(4, 3), (3, 4), (2, 3), (3, 2)]
)
def test_t_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_neighbors(self.grid.t_grid, 3, 3),
[(4, 3), (3, 4), (2, 3), (3, 2)]
)
def test_full_grid(self):
make_game_object(self)
self.assertEqual(
functions.get_neighbors(self.grid.fullgrid, 3, 3),
[(4, 3), (3, 4), (2, 3), (3, 2)]
)
class TestExpandPath(tcase):
def test(self):
make_game_object(self)
print functions.expandPath(self.grid.w_grid, self.grid.path)
def expandPath(grid, path):
newpath = []
for p in path:
newpath.append(p)
neighbors = get_neighbors(grid, p[0], p[1])
diagonals = get_diagonal(grid, p[0], p[1])
for d in diagonals:
if not d in newpath:
newpath.append(d)
for n in neighbors:
if not n in newpath:
newpath.append(n)
for n in newpath:
if n[0] == 8:
print(n)
return newpath
def get_dist(x1, y1, x2, y2): # Returns distance between to points
x = (x1 - x2) * (x1 - x2)
y = (y1 - y2) * (y1 - y2)
dist = math.sqrt(x + y)
return dist
def get_angle(x1, y1, x2, y2):
dx = x2 - x1
dy = y2 - y1
rads = math.atan2(-dy, dx)
rads %= 2*math.pi
return rads
if __name__ == '__main__':
unittest.main()
| cc0-1.0 | 8,512,238,743,295,567,000 | 24.611111 | 79 | 0.519439 | false |
dvdme/forecastiopy | tests/test_ForecastIO.py | 1 | 1494 | import os
import sys
import json
import unittest
from forecastiopy import *
class TestForecastIO(unittest.TestCase):
def setUp(self):
with open('tests/resources/dummy_apikey.txt') as f:
apikey = f.read()
self.fio = ForecastIO.ForecastIO(apikey)
with open('tests/resources/response.json') as f:
rsp = f.read()
self.fio.get_forecast_fromstr(rsp)
self.response = json.loads(rsp)
def test_get_url(self):
with open('tests/resources/dummy_apikey.txt') as f:
apikey = f.read()
fio = ForecastIO.ForecastIO(apikey)
with self.assertRaises(TypeError):
fio.get_url()
def test_invalid_apikey(self):
with self.assertRaises(ValueError):
self.fio = ForecastIO.ForecastIO('123')
def test_get_latitude(self):
self.assertEqual(self.fio.latitude, self.response['latitude'])
def test_get_longitude(self):
self.assertEqual(self.fio.longitude, self.response['longitude'])
def test_get_timezone(self):
self.assertEqual(self.fio.timezone, self.response['timezone'])
def test_get_offset(self):
self.assertEqual(self.fio.offset, self.response['offset'])
if __name__ == '__main__':
# append module root directory to sys.path
sys.path.append(
os.path.dirname(
os.path.dirname(
os.path.abspath(__file__)
)
)
)
unittest.main() | epl-1.0 | 843,940,500,443,580,300 | 27.75 | 72 | 0.605756 | false |
wbarfuss/pyunicorn | pyunicorn/climate/eventsynchronization_climatenetwork.py | 1 | 5600 | #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# This file is part of pyunicorn.
# Copyright (C) 2008--2015 Jonathan F. Donges and pyunicorn authors
# URL: <http://www.pik-potsdam.de/members/donges/software>
# License: BSD (3-clause)
"""
Provides class for the analysis of dynamical systems and time series based
on event synchronization
"""
# array object and fast numerics
import numpy as np
from ..funcnet import EventSynchronization
from .climate_network import ClimateNetwork
from .climate_data import ClimateData
from .. import Data
#
# Class definitions
#
class EventSynchronizationClimateNetwork(EventSynchronization, ClimateNetwork):
"""
Class EventSynchronizationClimateNetwork for generating and quantitatively
analyzing event synchronization networks.
References: [Boers2014]_.
"""
#
# Internal methods
#
def __init__(self, data, quantile_threshold, taumax,
eventsynctype="directedES", non_local=False,
node_weight_type="surface", silence_level=0):
"""
Initialize an instance of EventSynchronizationClimateNetwork.
For other applications of event synchronization networks please use
the event synchronization class directly.
:type data: :classL`..climate.ClimateData`
:arg data: The climate data used for network construction.
:type quantile_threshold: float between 0 and 1
:arg quantile_threshold: values above will be treated as events
:arg int taumax: Maximum dynamical delay
:type eventsynctype: str
:arg eventsynctype: one of "directedES", "symmetricES" or
"antisymmetricES" [default: "directed"]
:arg bool non_local: Determines, whether links between spatially close
nodes should be suppressed.
:arg str node_weight_type: The type of geographical node weight to be
used.
:arg int silence_level: The inverse level of verbosity of the object.
"""
etypes = ["directedES", "symmetricES", "antisymmetricES"]
if eventsynctype not in etypes:
raise IOError("wrong eventsynctype...\n" +
"Available options: '%s', '%s' or '%s'" %
(etypes[0], etypes[1], etypes[2]))
self.__eventsynctype = eventsynctype
self.directed = self.__eventsynctype != "symmetricES"
eventmatrix = data.observable() > np.percentile(data.observable(),
quantile_threshold*100,
axis=0)
EventSynchronization.__init__(self, eventmatrix.astype(int), taumax)
eventsyncmatrix = getattr(self, self.__eventsynctype)()
ClimateNetwork.__init__(self, grid=data.grid,
similarity_measure=eventsyncmatrix,
threshold=0,
non_local=non_local,
directed=self.directed,
node_weight_type=node_weight_type,
silence_level=silence_level)
def __str__(self):
"""
Return a string representation of TsonisClimateNetwork.
**Example:**
>>> data = EventSynchronizationClimateNetwork.SmallTestData()
>>> print EventSynchronizationClimateNetwork(data, 0.8, 16)
Extracting network adjacency matrix by thresholding...
Setting area weights according to type surface...
Setting area weights according to type surface...
EventSynchronizationClimateNetwork:
EventSynchronization: 6 variables, 10 timesteps, taumax: 16
ClimateNetwork:
GeoNetwork:
Network: directed, 6 nodes, 0 links, link density 0.000.
Geographical boundaries:
time lat lon
min 0.0 0.00 2.50
max 9.0 25.00 15.00
Threshold: 0
Local connections filtered out: False
Type of event synchronization to construct the network: directedES
"""
text = ("EventSynchronizationClimateNetwork: \n%s\n%s\n" +
"Type of event synchronization to construct the network: %s")
return text % (EventSynchronization.__str__(self),
ClimateNetwork.__str__(self), self.__eventsynctype)
@staticmethod
def SmallTestData():
"""
Return test data set of 6 time series with 10 sampling points each.
**Example:**
>>> r(Data.SmallTestData().observable())
array([[ 0. , 1. , 0. , -1. , -0. , 1. ],
[ 0.309 , 0.9511, -0.309 , -0.9511, 0.309 , 0.9511],
[ 0.5878, 0.809 , -0.5878, -0.809 , 0.5878, 0.809 ],
[ 0.809 , 0.5878, -0.809 , -0.5878, 0.809 , 0.5878],
[ 0.9511, 0.309 , -0.9511, -0.309 , 0.9511, 0.309 ],
[ 1. , 0. , -1. , -0. , 1. , 0. ],
[ 0.9511, -0.309 , -0.9511, 0.309 , 0.9511, -0.309 ],
[ 0.809 , -0.5878, -0.809 , 0.5878, 0.809 , -0.5878],
[ 0.5878, -0.809 , -0.5878, 0.809 , 0.5878, -0.809 ],
[ 0.309 , -0.9511, -0.309 , 0.9511, 0.309 , -0.9511]])
:rtype: ClimateData instance
:return: a ClimateData instance for testing purposes.
"""
data = Data.SmallTestData()
return ClimateData(observable=data.observable(), grid=data.grid,
time_cycle=5, silence_level=2)
| bsd-3-clause | -5,787,141,346,296,175,000 | 39.28777 | 79 | 0.572857 | false |
kristerhedfors/xnet | xnet/io/serialize.py | 1 | 6892 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright(c) 2013 Krister Hedfors
#
import unittest
import StringIO
import cPickle
import hashlib
import hmac
import struct
class NutException(Exception):
pass
class InvalidMagic(NutException):
pass
class InvalidLength(NutException):
pass
class InvalidSignature(NutException):
pass
class ReadCoreFailed(NutException):
pass
class Nut(object):
'''
A Nut is slightly harder than a pickle.
Nut is a serialized and signed object which produces
a length-overhead of 20 bytes compared to pickle.
BEWARE that the nut serialization use of keys and signatures
does nothing to provide security or integrity. These
mechanisms are only used as the equivalent of CRC checksums
to identify corrupt packets in the stream.
Byte layout:
4 magic
8 signature (of the two following fields)
4 flags
4 serialized_length
X core (pickled object)
'''
PICKLER = cPickle # or pickle
KEY = 'mAqVPwP2Ka7JElJelK5wnJfAWLVJ9NVooZYBSTOWlwc='.decode('base64')
MAGIC_NEXT = 'xNXT' # marks beginning of Nut
MAGIC_DONE = 'xDNE' # marks end of stream of Nuts
MAX_LENGTH = 65536 # of pickle; can be increased to 2**32-1
HASH_FN = hashlib.sha256
HASH_LENGTH = 8
class _Nothing:
pass
def __init__(self, obj=_Nothing, flags=0, pickler=PICKLER, key=KEY, max_length=MAX_LENGTH,
hash_fn=HASH_FN, hash_length=HASH_LENGTH):
self._flags = flags
self._pickler = pickler
self._key = key
self._max_length = max_length
self._hash_fn = hash_fn
self._hash_length = hash_length
if not obj is self._Nothing:
self.load_object(obj)
def _sign(self, msg):
digest = hmac.new(self._key, msg, digestmod=self.HASH_FN).digest()
digest = digest[:self.HASH_LENGTH]
return digest
def _serialize_length(self, s):
return struct.pack('I', len(s))
def _serialize_flags(self, f):
return struct.pack('I', f)
@classmethod
def _deserialize_length(self, sl):
tup = struct.unpack('I', sl)
assert len(tup) == 1
return tup[0]
@classmethod
def _deserialize_flags(self, sf):
tup = struct.unpack('I', sf)
assert len(tup) == 1
return tup[0]
def _signature(self):
msg = self._serialize_flags(self._flags)
msg += self._serialized_length
msg += self._core
return self._sign(msg)
def __str__(self):
'''
This returns the serialized representation.
'''
s = self.MAGIC_NEXT
s += self._signature()
s += self._serialize_flags(self._flags)
s += self._serialized_length
s += self._core
return s
def _get_flags(self):
return self._flags
def _set_flags(self, flags):
self._flags = flags
flags = property(_get_flags, _set_flags)
def _load(self, core):
self._core = core
self._serialized_length = self._serialize_length(self._core)
def load_object(self, obj, flags=None):
core = self._pickler.dumps(obj)
self._load(core)
if not flags is None:
self._set_flags(flags)
return self
def serialize(self):
return self.__str__()
def deserialize(self):
return self._pickler.loads(self._core)
@classmethod
def generate_from_stream(cls, stream, **nut_kwargs):
'''
stream must implement read().
'''
while True:
#
# read magic (4)
#
magic = stream.read(4)
if magic == cls.MAGIC_DONE:
break
if not magic == cls.MAGIC_NEXT:
raise InvalidMagic(magic)
nut = Nut(**nut_kwargs)
#
# read signature (8)
#
signature = stream.read(8)
#
# read flags (4)
#
_sflags = stream.read(4)
flags = cls._deserialize_flags(_sflags)
#
# read length (4)
#
_slength = stream.read(4)
length = cls._deserialize_length(_slength)
if not 0 < length <= nut._max_length:
raise InvalidLength(length)
#
# read core (length)
#
core = stream.read(length)
if not len(core) == length:
errmsg = '{0} < {1}'.format(len(core), length)
raise ReadCoreFailed(errmsg)
#
# validate signature
#
msg = _sflags + _slength + core
if not signature == nut._sign(msg):
errmsg = '{0} != {1}'.format(signature, nut._sign(msg))
raise InvalidSignature(errmsg)
#
# Validity of pickled object 'core' is not verified;
# pickle.loads() may throw.
#
nut._flags = flags
nut._load(core)
yield nut
class NutWriteWrapper(object):
def __init__(self, fobj, **nut_kwargs):
self._fobj = fobj
self._nut_kwargs = nut_kwargs
def write(self, buf):
nut = Nut(buf, **self._nut_kwargs)
buf = nut.serialize()
self._fobj.write(buf)
def close(self):
self._fobj.write(Nut.MAGIC_DONE)
self._fobj.close()
class Test_Nut(unittest.TestCase):
def setUp(self):
stream = StringIO.StringIO()
stream.write(Nut('asd', flags=0))
stream.write(Nut(123, flags=1))
stream.write(Nut([1, 3.14, None], flags=2))
stream.write(Nut({'asd': 123, 'qwe': 'rty'}, flags=3))
#stream.write(Nut(dict(foo=Nut('bar'))))
stream.write(Nut.MAGIC_DONE)
stream.seek(0)
self._stream = stream
def test1(self):
a1 = Nut(1, key='a')
a2 = Nut(2, key='a')
b1 = Nut(1, key='b')
b2 = Nut(2, key='b')
assert 1 == a1.deserialize() == b1.deserialize()
assert 2 == a2.deserialize() == b2.deserialize()
assert str(a1) != str(a2) != str(b1) != str(b2)
def test2(self):
stream = self._stream
stream.seek(0)
for (i, nut) in enumerate(Nut.generate_from_stream(stream)):
obj = nut.deserialize()
assert nut.flags == i
print obj
def test3(self):
import sys
out = NutWriteWrapper(sys.stdout)
out.write('test3 123123')
out.write('test3 QWEQWE')
out.write('test3 foo')
out.write('test3 111111111111')
out.close()
def _test():
import doctest
import unittest
print(doctest.testmod())
unittest.main()
if __name__ == "__main__":
_test()
| bsd-3-clause | 241,163,241,223,117,340 | 25.205323 | 94 | 0.542078 | false |
gangeli/NaturalLI | pub/acl2015/pr_plot.py | 1 | 1168 | #!/usr/bin/env python
#
import sys
import matplotlib.pyplot as plt
#if len(sys.argv) < 4:
# print "Usage: File xlimit ylimit"
def pr(f):
precisions = []
recalls = []
with open(f, 'r') as f:
for line in f:
p, r = line.split("\t")
precisions.append(float(p))
recalls.append(float(r))
return [precisions, recalls]
plt.clf()
ax = plt.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
[precisions, recalls] = pr('final_results/ollie.plot');
plt.plot(recalls, precisions, label="Ollie", linewidth=3.0, linestyle=':', color='red')
[precisions, recalls] = pr('final_results/our_system_nonominals.plot');
plt.plot(recalls, precisions, label="Our System (without nominals)", linewidth=3.0, linestyle='-', color='green')
#[precisions, recalls] = pr('final_results/our_system_names_websites.plot');
#plt.plot(recalls, precisions, label="Our System + Alt. Name + Website")
plt.ylabel("Precision")
plt.xlabel("Recall")
plt.ylim([0.0, 1.0])
plt.xlim([0.0, 0.15])
plt.legend() #loc="lower left")
plt.savefig('pr_curve.pdf')
| mit | 6,420,919,372,658,777,000 | 25.545455 | 113 | 0.663527 | false |
AlexandreBiguet/NJLlikeModels | PythonStuffs/pnjlA.py | 1 | 3199 | #!/opt/local/bin/python
# coding: utf8
from scipy import optimize
from scipy import integrate
from pathlib import Path
import numpy as np
import sys
import njlA
import utils
class MpnjlA ( njlA.MnjlA ):
def __init__ ( self ):
njlA.MnjlA.__init__(self)
self.Phi = 0.0
self.Phi_min = 0.0
self.Phi_max = 0.999
def evalGp (self):
pass
def evalMFE ( self, s, Phi, T, mu ):
pass
def minGp ( self, min_method = "L-BFGS-B" ):
def Gp ( s, Phi ):
self.s = s
self.Phi = Phi
return self.evalGp()
GpFunc = lambda x: Gp ( x[0], x[1] )
s = self.s
Phi = self.Phi
xguess = [ s, Phi ]
bnds = ((self.s_min, self.s_max), (self.Phi_min, self.Phi_max))
res = optimize.minimize( GpFunc, xguess, method=min_method, bounds=bnds)
self.s = res[0]
self.Phi = res[1]
return res
def solMFE (self):
pass
def solMFE_s_Phi (self):
F = lambda x: self.evalMFE( x[0], x[1], self.T, self.mu )
xg = [ self.s, self.Phi ]
sol = optimize.root( F, xg, method='hybr' )
self.s = sol.x[0]
self.Phi = sol.x[1]
return sol
def solMFE_s_T (self):
F = lambda x: self.evalMFE( x[0], self.Phi, x[1], self.mu )
xg = [ self.s, self.T ]
sol = optimize.root( F, xg, method='hybr' )
self.s = sol.x[0]
self.T = sol.x[1]
return sol
def solMFE_s_mu (self):
F = lambda x: self.evalMFE( x[0], self.Phi, self.T, x[1])
xg = [ self.s, self.mu ]
sol = optimize.root( F, xg, method='hybr' )
self.s = sol.x[0]
self.mu = sol.x[1]
return sol
def solMFE_Phi_T (self):
F = lambda x: self.evalMFE( self.s, x[0], x[1], self.mu )
xg = [ self.Phi, self.T ]
sol = optimize.root( F, xg, method='hybr' )
self.Phi = sol.x[0]
self.T = sol.x[1]
return sol
def solMFE_Phi_mu (self):
F = lambda x: self.evalMFE( self.s, x[0], self.T, x[1])
xg = [ self.Phi, self.mu ]
sol = optimize.root( F, xg, method='hybr' )
self.Phi = sol.x[0]
self.mu = sol.x[1]
return sol
def set_sol ( self, sol=["s", "Phi"] ):
if utils.isContained( sol, ["s", "Phi" ]) :
self.solMFE = self.solMFE_s_Phi
elif utils.isContained (sol , ["s", "T"] ):
self.solMFE = self.solMFE_s_T
elif utils.isContained (sol , ["s", "mu"]):
self.solMFE = self.solMFE_s_mu
elif utils.isContained (sol , ["Phi", "T"] ):
self.solMFE = self.solMFE_Phi_T
elif utils.isContained (sol , ["Phi", "mu"]):
self.solMFE = self.solMFE_Phi_mu
else:
print ("\n", sol, ": ")
sys.exit("Unknown sol variables" )
if __name__ == "__main__":
from scipy import optimize
from scipy import integrate
from pathlib import Path
import numpy as np
import sys
import njlA
import utils
M = MpnjlA ()
print ( M.s_min, " ", M.Utype )
M.set_sol ( ["mu", "s"] )
| gpl-3.0 | 5,631,456,100,910,675,000 | 27.061404 | 80 | 0.500156 | false |
Elian-0x/practice-python | tutos/How to Think Like a Computer Scientist/chap7.py | 1 | 3387 | #!/usr/local/bin/python
# -*- coding: utf-8 -*-
# Learning python like a computer scientist chap7
# Elian
# Les chaines de caracteres
'''
Elles sont immutables, il n'est donc pas possible de modifier une
chaîne existante sans en créer une nouvelle
'''
import string
nom="Elian"
def ecrire_inverse(s):
length=len(s)
while length>=1:
print s[length-1]
length=length-1
# Renvoie l'index d'un caractere (première ocurrence)
def findindex(s,car):
index=0
while index<len(s):
if s[index]==car:
return index
index=index+1
return -1 # code d'erreur
# Renvoie l'index d'un caractere depuis un index donné
def findindexpos(s,car,pos):
index=pos # index de départ
while index<len(s):
if s[index]==car:
return index
index=index+1
return -1
# Compte le nombre d'occurrence d'un caractere
def nbOcc(s,car):
nb=0
for carac in s:
if carac==car:
nb=nb+1
return nb
# Compte le nombre d'occurrence d'un caractere
# depuis un index donné
def nbOccPos(s,car,pos):
nb=0
index=pos
while index<len(s):
if s[index]==car:
nb=nb+1
index=index+1
return nb
# Détermine si un caractere est une minuscule
def isLower(ch):
return string.find(string.lowercase,ch) != -1
# idem return ch in string.lowercase
# idem return ’a’ <= ch <= ’z’
#---=] Main [=-------------------------------------------------------
print nom[0], # premier caractere index à partir de 0
print nom[1]
print "Length:", len(nom)
length=len(nom)
last_car=nom[length-1] # dernier caractere
dernier_car=nom[-1] # idem avec index negatif
print "dernier caractere =", last_car, dernier_car
# traitement des caracteres un par un
index=0
while index<len(nom):
print nom[index],
index=index+1
print "\nA l'envers, une lettre par ligne"
ecrire_inverse(nom)
# Traverser chaque caractere d'une chaine
for car in nom:
print car,
print "\n"
# Concaténation
prefixes="JKLMNOPQ"
suffixe="ack"
for lettres in prefixes:
if lettres == "O" or lettres=="Q":
print lettres+"u"+suffixe
else:
print lettres+suffixe
# Sous chaines
noms="Joe, Steve, me"
print noms[0:3], noms[5:10], noms[12:14] # index du dernier car+1
print noms[:10] # en partant du debut
print noms[5:] # d'un index à la fin
print noms[:] # totalité de la chaine
# Comparaisons de chaines
ch1="abcd"
ch2="abcde"
if ch1==ch2:
print "les 2 chaines sont égales"
else:
print "les 2 chaines sont différentes"
ch1="Elian"
ch2="me"
# Tri par ordre alphabétique
# Attention les majuscules sont avant les minuscules donc pour
# un tri, tout convertir avant dans l'un des 2 types
if ch1<ch2:
print ch1, ch2
else:
print ch2,ch1
# Index d'un caractere
print "index 1ere occurrence de i =",findindex(nom,'i')
print "index à partir d'une position =",findindexpos(nom,'i',2)
# Nombre d'occurrence d'un caractere
print "Nb occurrence de i =",nbOcc(nom,'i')
nom="ElianElian"
print "Nb occurrence à partir pos =",nbOccPos(nom,'i',4)
# Fonctions du module string
chaine="Elianpacmand"
print "index d=",string.find(chaine,'d')
print "index depuis pos=",string.find(chaine,'i',2)
print "index sous chaine nd=",string.find(chaine,'nd')
print "index entre les rang 6 à 10 =",string.find(chaine,'i',6,10)
print string.lowercase
print string.uppercase
print string.digits
print "i is lower?",isLower('i')
print "J is lower?",isLower('J')
print string.whitespace,"espace" # espace, \t, \n
| gpl-3.0 | -8,941,041,229,237,536,000 | 18.660819 | 69 | 0.692445 | false |
Facerafter/starcitizen-tools | extensions/EventLogging/server/tests/test_load.py | 1 | 7720 | # -*- coding: utf-8 -*-
"""
This script generates a stream of requests to beta-labs
(bits.beta.wmflabs.org) to test EventLogging load limitations.
Thanks to Emilio Monti for the Worker and ThreadPool codes!
https://code.activestate.com/recipes/577187-python-thread-pool/
"""
import json
import time
import string
import random
import urllib
import httplib
import argparse
from threading import Thread
from Queue import Queue
POOL_SIZE = 100
SCHEMA_HOST = 'meta.wikimedia.org'
SCHEMA_URL = ('/w/api.php?action=query&prop=revisions&format=json'
'&rvprop=content&titles=Schema:%s&revid=%s')
CAPSULE_REVISION = 10981547
EL_URL = '/event.gif?%s;'
class Worker(Thread):
"""Thread executing tasks from a given tasks queue"""
def __init__(self, tasks):
Thread.__init__(self)
self.tasks = tasks
self.daemon = True
self.start()
def run(self):
while True:
func, args, kargs = self.tasks.get()
try:
func(*args, **kargs)
except Exception, e:
print 'Worker error: %s.' % e
self.tasks.task_done()
class ThreadPool(object):
"""Pool of threads consuming tasks from a queue"""
def __init__(self, num_threads):
self.tasks = Queue(num_threads)
for _ in range(num_threads):
Worker(self.tasks)
def add_task(self, func, *args, **kargs):
"""Add a task to the queue"""
self.tasks.put((func, args, kargs))
def wait_completion(self):
"""Wait for completion of all the tasks in the queue"""
self.tasks.join()
class EventGenerator(object):
"""Generates events for a given schema."""
def __init__(self, schema_name, schema_revision):
self.schema_name = schema_name
self.schema_revision = schema_revision
try:
self.schema = get_schema(schema_name, schema_revision)
except Exception:
raise RuntimeError(
'Could not retrieve schema information: %s.' % schema_name)
def generate(self, capsule_schema, optional_values):
event = self.instantiate(capsule_schema, optional_values)
event['schema'] = self.schema_name
event['revision'] = self.schema_revision
event['timestamp'] = int(time.time())
event['event'] = self.instantiate(self.schema, optional_values)
return event
def instantiate(self, schema, optional_values):
event = {}
for name, prop in schema['properties'].iteritems():
# Decide if the property should be instantiated
if (prop.get('required', None) or optional_values == 'always' or
(optional_values == 'sometimes' and random.random() < .2)):
# Instantiate depending on kind of property
if 'enum' in prop:
value = random.choice(prop['enum'])
else:
prop_type = prop['type']
if prop_type in ['integer', 'number']:
value = random.randint(0, 99)
elif prop_type == 'boolean':
value = random.random() < 0.5
elif prop_type == 'string':
value = self.random_string(2)
elif prop_type == 'object':
pass # only event capsule has that
else:
raise ValueError(
'Unexpected property type: %s' % prop_type)
event[name] = value
return event
def random_string(self, length):
alphabet = (string.ascii_uppercase + string.digits +
string.ascii_lowercase)
return ''.join(random.choice(alphabet) for _ in range(length))
def get_schema(schema_name, schema_revision):
conn = httplib.HTTPSConnection(SCHEMA_HOST)
conn.request("GET", SCHEMA_URL % (schema_name, schema_revision))
data = json.loads(conn.getresponse().read())
pages = data['query']['pages']
page_id = pages.keys()[0]
schema_str = pages[page_id]['revisions'][0]['*']
return json.loads(schema_str)
def send_event(event, endpoint):
query_string = urllib.quote(json.dumps(event))
conn = httplib.HTTPConnection(endpoint)
conn.request("GET", EL_URL % query_string)
def get_arguments():
# Get argparse params.
ap = argparse.ArgumentParser(
description='EventLogging load tester',
fromfile_prefix_chars='@')
ap.add_argument(
'events_per_second',
help='Number of total of events per second that will be sent.',
default='100')
ap.add_argument(
'-s', '--schema',
help=('Format: "SchemaName:Revision:Share". Example: '
'"Edit:11448630:0.35". SchemaName and Revision indicate a '
'schema for which events will be sent. Share indicates the '
'proportion of events for that schema (Integer or float).'),
action='append')
ap.add_argument(
'--optional-values',
help=('Indicates when to instantiate optional event fields. '
'Possible values: "never", "sometimes" and "always".'),
default='sometimes')
ap.add_argument(
'--endpoint',
help=('Hostname where events should be sent. '
'E.g. bits.wikimedia.org'),
default='bits.beta.wmflabs.org')
args = ap.parse_args()
# Check and build sleep interval param.
try:
events_per_second = int(args.events_per_second)
sleep_interval = 1.0 / events_per_second
except ValueError:
raise ValueError('Invalid parameter events_per_second: %s.' %
args.events_per_second)
# Check and build generators param.
generators = []
if args.schema:
for schema in args.schema:
try:
schema_name, schema_revision, schema_share = schema.split(':')
schema_revision = int(schema_revision)
schema_share = float(schema_share)
except ValueError:
raise ValueError('Invalid parameter -s/--schema: %s.' % schema)
generator = EventGenerator(schema_name, schema_revision)
generators.append((generator, schema_share))
# Check and build optional values param.
optional_values = 'sometimes'
if args.optional_values:
if args.optional_values in ['never', 'sometimes', 'always']:
optional_values = args.optional_values
else:
raise ValueError('Invalid parameter --optional-values: %s.' %
args.optional_values)
return sleep_interval, generators, optional_values, args.endpoint
def weighted_choice(choices):
total = sum(w for c, w in choices)
r = random.uniform(0, total)
upto = 0
for c, w in choices:
if upto + w > r:
return c
upto += w
def main():
print 'Initializing...'
sleep_interval, generators, optional_values, endpoint = get_arguments()
capsule_schema = get_schema('EventCapsule', CAPSULE_REVISION)
pool = ThreadPool(POOL_SIZE)
print 'Sending events...'
count = 0
try:
while True:
t1 = time.time()
generator = weighted_choice(generators)
event = generator.generate(capsule_schema, optional_values)
pool.add_task(send_event, event, endpoint)
t2 = time.time()
count += 1
time_to_sleep = max(sleep_interval - (t2 - t1), 0)
time.sleep(time_to_sleep)
except KeyboardInterrupt:
print '\n%d events sent, exiting.' % count
if __name__ == '__main__':
main()
| gpl-3.0 | -1,500,287,337,348,135,200 | 33.774775 | 79 | 0.585363 | false |
lbdreyer/nc-time-axis | nc_time_axis/__init__.py | 1 | 10445 | """
Support for netcdftime axis in matplotlib.
"""
from __future__ import (absolute_import, division, print_function)
from six.moves import (filter, input, map, range, zip) # noqa
from collections import namedtuple
import matplotlib.dates as mdates
import matplotlib.ticker as mticker
import matplotlib.transforms as mtransforms
import matplotlib.units as munits
import netcdftime
import numpy as np
# Define __version__ based on versioneer's interpretation.
from ._version import get_versions
__version__ = get_versions()['version']
del get_versions
# Lower and upper are in number of days.
FormatOption = namedtuple('FormatOption', ['lower', 'upper', 'format_string'])
class CalendarDateTime(object):
"""
Container for :class:`netcdftime.datetime` object and calendar.
"""
def __init__(self, datetime, calendar):
self.datetime = datetime
self.calendar = calendar
def __eq__(self, other):
return (isinstance(other, self.__class__) and
self.datetime == other.datetime and
self.calendar == other.calendar)
def __ne__(self, other):
return not self.__eq__(other)
def __repr__(self):
msg = '<{}: datetime={}, calendar={}>'
return msg.format(type(self).__name__, self.datetime, self.calendar)
class NetCDFTimeDateFormatter(mticker.Formatter):
"""
Formatter for netcdftime.datetime data.
"""
# Some magic numbers. These seem to work pretty well.
format_options = [FormatOption(0.0, 0.2, '%H:%M:%S'),
FormatOption(0.2, 0.8, '%H:%M'),
FormatOption(0.8, 15, '%Y-%m-%d %H:%M'),
FormatOption(15, 90, '%Y-%m-%d'),
FormatOption(90, 900, '%Y-%m'),
FormatOption(900, 6000000, '%Y')]
def __init__(self, locator, calendar, time_units):
#: The locator associated with this formatter. This is used to get hold
#: of the scaling information.
self.locator = locator
self.calendar = calendar
self.time_units = time_units
def pick_format(self, ndays):
"""
Returns a format string for an interval of the given number of days.
"""
for option in self.format_options:
if option.lower < ndays <= option.upper:
return option.format_string
else:
msg = 'No formatter found for an interval of {} days.'
raise ValueError(msg.format(ndays))
def __call__(self, x, pos=0):
format_string = self.pick_format(ndays=self.locator.ndays)
dt = netcdftime.utime(self.time_units, self.calendar).num2date(x)
return dt.strftime(format_string)
class NetCDFTimeDateLocator(mticker.Locator):
"""
Determines tick locations when plotting netcdftime.datetime data.
"""
def __init__(self, max_n_ticks, calendar, date_unit, min_n_ticks=3):
# The date unit must be in the form of days since ...
self.max_n_ticks = max_n_ticks
self.min_n_ticks = min_n_ticks
self._max_n_locator = mticker.MaxNLocator(max_n_ticks, integer=True)
self._max_n_locator_days = mticker.MaxNLocator(
max_n_ticks, integer=True, steps=[1, 2, 4, 7, 14])
self.calendar = calendar
self.date_unit = date_unit
if not self.date_unit.lower().startswith('days since'):
msg = 'The date unit must be days since for a NetCDF time locator.'
raise ValueError(msg)
self._cached_resolution = {}
def compute_resolution(self, num1, num2, date1, date2):
"""
Returns the resolution of the dates (hourly, minutely, yearly), and
an **approximate** number of those units.
"""
num_days = float(np.abs(num1 - num2))
resolution = 'SECONDLY'
n = mdates.SEC_PER_DAY
if num_days * mdates.MINUTES_PER_DAY > self.max_n_ticks:
resolution = 'MINUTELY'
n = int(num_days / mdates.MINUTES_PER_DAY)
if num_days * mdates.HOURS_PER_DAY > self.max_n_ticks:
resolution = 'HOURLY'
n = int(num_days / mdates.HOURS_PER_DAY)
if num_days > self.max_n_ticks:
resolution = 'DAILY'
n = int(num_days)
if num_days > 30 * self.max_n_ticks:
resolution = 'MONTHLY'
n = num_days // 30
if num_days > 365 * self.max_n_ticks:
resolution = 'YEARLY'
n = abs(date1.year - date2.year)
return resolution, n
def __call__(self):
vmin, vmax = self.axis.get_view_interval()
return self.tick_values(vmin, vmax)
def tick_values(self, vmin, vmax):
vmin, vmax = mtransforms.nonsingular(vmin, vmax, expander=1e-7,
tiny=1e-13)
self.ndays = float(abs(vmax - vmin))
utime = netcdftime.utime(self.date_unit, self.calendar)
lower = utime.num2date(vmin)
upper = utime.num2date(vmax)
resolution, n = self.compute_resolution(vmin, vmax, lower, upper)
if resolution == 'YEARLY':
# TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
# appropriate.
years = self._max_n_locator.tick_values(lower.year, upper.year)
ticks = [netcdftime.datetime(int(year), 1, 1) for year in years]
elif resolution == 'MONTHLY':
# TODO START AT THE BEGINNING OF A DECADE/CENTURY/MILLENIUM as
# appropriate.
months_offset = self._max_n_locator.tick_values(0, n)
ticks = []
for offset in months_offset:
year = lower.year + np.floor((lower.month + offset) / 12)
month = ((lower.month + offset) % 12) + 1
ticks.append(netcdftime.datetime(int(year), int(month), 1))
elif resolution == 'DAILY':
# TODO: It would be great if this favoured multiples of 7.
days = self._max_n_locator_days.tick_values(vmin, vmax)
ticks = [utime.num2date(dt) for dt in days]
elif resolution == 'HOURLY':
hour_unit = 'hours since 2000-01-01'
hour_utime = netcdftime.utime(hour_unit, self.calendar)
in_hours = hour_utime.date2num([lower, upper])
hours = self._max_n_locator.tick_values(in_hours[0], in_hours[1])
ticks = [hour_utime.num2date(dt) for dt in hours]
elif resolution == 'MINUTELY':
minute_unit = 'minutes since 2000-01-01'
minute_utime = netcdftime.utime(minute_unit, self.calendar)
in_minutes = minute_utime.date2num([lower, upper])
minutes = self._max_n_locator.tick_values(in_minutes[0],
in_minutes[1])
ticks = [minute_utime.num2date(dt) for dt in minutes]
elif resolution == 'SECONDLY':
second_unit = 'seconds since 2000-01-01'
second_utime = netcdftime.utime(second_unit, self.calendar)
in_seconds = second_utime.date2num([lower, upper])
seconds = self._max_n_locator.tick_values(in_seconds[0],
in_seconds[1])
ticks = [second_utime.num2date(dt) for dt in seconds]
else:
msg = 'Resolution {} not implemented yet.'.format(resolution)
raise ValueError(msg)
return utime.date2num(ticks)
class NetCDFTimeConverter(mdates.DateConverter):
"""
Converter for netcdftime.datetime data.
"""
standard_unit = 'days since 2000-01-01'
@staticmethod
def axisinfo(unit, axis):
"""
Returns the :class:`~matplotlib.units.AxisInfo` for *unit*.
*unit* is a tzinfo instance or None.
The *axis* argument is required but not used.
"""
calendar, date_unit = unit
majloc = NetCDFTimeDateLocator(4, calendar=calendar,
date_unit=date_unit)
majfmt = NetCDFTimeDateFormatter(majloc, calendar=calendar,
time_units=date_unit)
datemin = CalendarDateTime(netcdftime.datetime(2000, 1, 1), calendar)
datemax = CalendarDateTime(netcdftime.datetime(2010, 1, 1), calendar)
return munits.AxisInfo(majloc=majloc, majfmt=majfmt, label='',
default_limits=(datemin, datemax))
@classmethod
def default_units(cls, sample_point, axis):
"""
Computes some units for the given data point.
"""
try:
# Try getting the first item. Otherwise we just use this item.
sample_point = sample_point[0]
except (TypeError, IndexError):
pass
if not hasattr(sample_point, 'calendar'):
msg = 'Expecting netcdftimes with an extra "calendar" attribute.'
raise ValueError(msg)
return sample_point.calendar, cls.standard_unit
@classmethod
def convert(cls, value, unit, axis):
"""
Converts value, if it is not already a number or sequence of numbers,
with :func:`netcdftime.utime().date2num`.
"""
if isinstance(value, np.ndarray):
# Don't do anything with numeric types.
if value.dtype != np.object:
return value
first_value = value[0]
else:
# Don't do anything with numeric types.
if munits.ConversionInterface.is_numlike(value):
return value
first_value = value
if not isinstance(first_value, CalendarDateTime):
raise ValueError('The values must be numbers or instances of '
'"nc_time_axis.CalendarDateTime".')
if not isinstance(first_value.datetime, netcdftime.datetime):
raise ValueError('The datetime attribute of the CalendarDateTime '
'object must be of type `netcdftime.datetime`.')
ut = netcdftime.utime(cls.standard_unit, calendar=first_value.calendar)
if isinstance(value, CalendarDateTime):
value = [value]
return ut.date2num([v.datetime for v in value])
# Automatically register NetCDFTimeConverter with matplotlib.unit's converter
# dictionary.
if CalendarDateTime not in munits.registry:
munits.registry[CalendarDateTime] = NetCDFTimeConverter()
| bsd-3-clause | 7,312,765,437,910,256,000 | 36.437276 | 79 | 0.589086 | false |
nave91/dbt | test/integration/012_profile_config_tests/test_profile_config.py | 1 | 1413 | from nose.plugins.attrib import attr
from test.integration.base import DBTIntegrationTest
import dbt.deprecations
class TestNoRunTargetDeprecation(DBTIntegrationTest):
def setUp(self):
DBTIntegrationTest.setUp(self)
self.run_sql_file("test/integration/012_profile_config_tests/seed.sql")
dbt.deprecations.reset_deprecations()
@property
def schema(self):
return "profile_config_012"
@property
def models(self):
return "test/integration/012_profile_config_tests/models"
@property
def profile_config(self):
return {
'test': {
'outputs': {
'my-target': {
'type': 'postgres',
'threads': 1,
'host': 'database',
'port': 5432,
'user': 'root',
'pass': 'password',
'dbname': 'dbt',
'schema': self.unique_schema()
}
},
'target': 'my-target'
}
}
@attr(type='postgres')
def test_deprecated_run_target_config(self):
results = self.run_dbt()
self.assertEqual(len(results), 1)
self.assertTablesEqual("seed","view_model")
self.assertFalse('run-target' in dbt.deprecations.active_deprecations)
| apache-2.0 | -2,097,655,783,617,538,300 | 28.4375 | 79 | 0.519462 | false |
uts-magic-lab/pyride_nao | scripts/py_main.py | 1 | 2931 | import PyNAO
import math
import constants
import tinstate
import messenger
import tininfo
import time
from timers import timermanager
myMessenger = None
msgTryTimer = -1
calTryTimer = -1
cktime = time.time()
def userLogon( name ):
PyNAO.say( '%s has logged on.' % name )
tinstate.updateStatus( constants.USER_PRESENT, False )
def userLogoff( name ):
PyNAO.say( '%s has logged off.' % name )
tinstate.updateStatus( constants.USER_PRESENT, len(PyNAO.listCurrentUsers()) == 0)
def bumperActions( id ):
global cktime
if time.time() - cktime <= 60:
return #ignore
if id == 'right':
users = PyNAO.listCurrentUsers()
if len(users) == 0:
PyNAO.say( 'No one is telepresent.' )
else:
PyNAO.say( 'Following users are telepresent:' )
for i in users:
PyNAO.say( '\pau=1000\ %s' % i )
elif id == 'left':
if len(PyNAO.listCurrentUsers()) > 0:
PyNAO.say( 'I will notify the telepresent members to tune in.' )
PyNAO.updateOperationalStatus( constants.CUSTOM_STATE, 'Need your attention' )
cktime = time.time()
def remoteCommandActions( cmd, arg ):
pass
def timerLapsedActions( id ):
timermanager.onTimerLapsed( id )
def timerActions( id ):
global myMessenger, msgTryTimer
if msgTryTimer == id and myMessenger.checkin():
PyNAO.removeTimer( msgTryTimer )
msgTryTimer = -1
else:
timermanager.onTimerCall( id )
def chestBtnActions( id ):
global myMessenger, purgeuser
if id == 1:
myMessenger.announce()
#do report messages
elif id == 2:
myMessenger.purgearchive()
elif id == 3:
PyNAO.say( constants.INTRO_TEXT )
def powerPlugChangeActions( isplugged ):
global myMessenger
text = ""
if isplugged:
text = "I'm on main power."
else:
text = "I'm on battery power."
PyNAO.say( text )
if myMessenger:
myMessenger.updatestatus( text )
def batteryChargeChangeActions( batpc, isdischarge ):
global myMessenger
if batpc < 20 and isdischarge:
PyNAO.say( "I'm low on battery, please put me back on main power." )
if myMessenger:
myMessenger.updatestatus( "I have only %d percent battery power left!" % batpc )
def systemShutdownActions():
global myMessenger
myMessenger.checkout()
PyNAO.say( "I am going off line. Goodbye." )
def main():
global myMessenger, msgTryTimer
PyNAO.onUserLogOn = userLogon
PyNAO.onUserLogOff = userLogoff
PyNAO.onBumperPressed = bumperActions
PyNAO.onTimer = timerActions
PyNAO.onTimerLapsed = timerLapsedActions
PyNAO.onRemoteCommand = remoteCommandActions
PyNAO.onChestButtonPressed = chestBtnActions
PyNAO.onSystemShutdown = systemShutdownActions
PyNAO.onPowerPluggedChange = powerPlugChangeActions
PyNAO.onBatteryChargeChange = batteryChargeChangeActions
PyNAO.say( constants.INTRO_TEXT )
myMessenger = messenger.Messenger()
if not myMessenger.checkin():
msgTryTimer = PyNAO.addTimer( 10*60, -1, 10*60 )
| gpl-3.0 | 5,249,737,204,137,457,000 | 23.838983 | 86 | 0.707608 | false |
KonradBreitsprecher/espresso | testsuite/dawaanr-and-bh-gpu.py | 1 | 5810 | from __future__ import print_function
import math
import unittest as ut
import numpy as np
from numpy import linalg as la
from numpy.random import random, seed
import espressomd
from espressomd.interactions import *
from espressomd.magnetostatics import *
from espressomd.analyze import *
from tests_common import *
from espressomd import assert_features, has_features, missing_features
@ut.skipIf(not has_features(["DIPOLAR_BARNES_HUT"]),
"Features not available, skipping test!")
class BHGPUTest(ut.TestCase):
longMessage = True
# Handle for espresso system
system = espressomd.System(box_l=[1,1,1])
def vectorsTheSame(self,a,b):
tol = 5E-2
vec_len = la.norm(a - b)
rel = 2 * vec_len / (la.norm(a) + la.norm(b))
if rel <= tol:
return True
else:
return False
def stopAll(self):
for i in range(len(self.system.part)):
self.system.part[i].v = np.array([0.0,0.0,0.0])
self.system.part[i].omega_body = np.array([0.0,0.0,0.0])
def run_test_case(self):
seed(1)
pf_bh_gpu = 2.34
pf_dawaanr = 3.524
ratio_dawaanr_bh_gpu = pf_dawaanr / pf_bh_gpu
l = 15
self.system.box_l = [l, l, l]
self.system.periodicity = [0, 0, 0]
self.system.time_step = 1E-4
self.system.cell_system.skin = 0.1
part_dip = np.zeros((3))
for n in [ 110, 111, 540, 541, 5946 ]:
dipole_modulus = 1.3
# scale the box for a large number of particles:
if n > 1000:
l *= (n / 541) ** (1 / 3.0)
for i in range(n):
part_pos = np.array(random(3)) * l
costheta = 2 * random() - 1
sintheta = np.sin(np.arcsin(costheta))
phi = 2 * np.pi * random()
part_dip[0] = sintheta * np.cos(phi) * dipole_modulus
part_dip[1] = sintheta * np.sin(phi) * dipole_modulus
part_dip[2] = costheta * dipole_modulus
self.system.part.add(id = i, type = 0, pos = part_pos, dip = part_dip, v = np.array([0,0,0]), omega_body = np.array([0,0,0]))
self.system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=10.0, sigma=0.5,
cutoff=0.55, shift="auto")
self.system.thermostat.set_langevin(kT=0.0, gamma=10.0)
self.stopAll()
self.system.integrator.set_vv()
self.system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=0.0, sigma=0.0,
cutoff=-1, shift=0.0)
self.system.cell_system.skin = 0.0
self.system.time_step = 0.01
self.system.thermostat.turn_off()
# gamma should be zero in order to avoid the noise term in force and torque
self.system.thermostat.set_langevin(kT=1.297, gamma=0.0)
dds_cpu = DipolarDirectSumCpu(prefactor = pf_dawaanr)
self.system.actors.add(dds_cpu)
self.system.integrator.run(steps = 0,recalc_forces = True)
dawaanr_f = []
dawaanr_t = []
for i in range(n):
dawaanr_f.append(self.system.part[i].f)
dawaanr_t.append(self.system.part[i].torque_lab)
dawaanr_e = Analysis(self.system).energy()["total"]
del dds_cpu
for i in range(len(self.system.actors.active_actors)):
self.system.actors.remove(self.system.actors.active_actors[i])
self.system.integrator.run(steps = 0,recalc_forces = True)
bh_gpu = DipolarBarnesHutGpu(prefactor = pf_bh_gpu, epssq = 200.0, itolsq = 8.0)
self.system.actors.add(bh_gpu)
self.system.integrator.run(steps = 0,recalc_forces = True)
bhgpu_f = []
bhgpu_t = []
for i in range(n):
bhgpu_f.append(self.system.part[i].f)
bhgpu_t.append(self.system.part[i].torque_lab)
bhgpu_e = Analysis(self.system).energy()["total"]
# compare
for i in range(n):
self.assertTrue(self.vectorsTheSame(np.array(dawaanr_t[i]),ratio_dawaanr_bh_gpu * np.array(bhgpu_t[i])), \
msg = 'Torques on particle do not match. i={0} dawaanr_t={1} ratio_dawaanr_bh_gpu*bhgpu_t={2}'.format(i,np.array(dawaanr_t[i]), ratio_dawaanr_bh_gpu * np.array(bhgpu_t[i])))
self.assertTrue(self.vectorsTheSame(np.array(dawaanr_f[i]),ratio_dawaanr_bh_gpu * np.array(bhgpu_f[i])), \
msg = 'Forces on particle do not match: i={0} dawaanr_f={1} ratio_dawaanr_bh_gpu*bhgpu_f={2}'.format(i,np.array(dawaanr_f[i]), ratio_dawaanr_bh_gpu * np.array(bhgpu_f[i])))
self.assertTrue(abs(dawaanr_e - bhgpu_e * ratio_dawaanr_bh_gpu) <= abs(1E-3 * dawaanr_e), \
msg = 'Energies for dawaanr {0} and bh_gpu {1} do not match.'.format(dawaanr_e,ratio_dawaanr_bh_gpu * bhgpu_e))
self.system.integrator.run(steps = 0,recalc_forces = True)
del bh_gpu
for i in range(len(self.system.actors.active_actors)):
self.system.actors.remove(self.system.actors.active_actors[i])
self.system.part.clear()
def test(self):
if (self.system.cell_system.get_state()["n_nodes"] > 1):
print("NOTE: Ignoring testcase for n_nodes > 1")
else:
self.run_test_case()
if __name__ == '__main__':
print("Features: ", espressomd.features())
ut.main()
| gpl-3.0 | 3,505,035,319,132,454,000 | 41.720588 | 205 | 0.543373 | false |
richtermondt/ankiqt | ankiqt/ui/getshared.py | 1 | 8977 | # -*- coding: utf-8 -*-
# Copyright: Damien Elmes <[email protected]>
# License: GNU GPL, version 3 or later; http://www.gnu.org/copyleft/gpl.html
from PyQt4.QtGui import *
from PyQt4.QtCore import *
import ankiqt, simplejson, time, cStringIO, zipfile, tempfile, os, re
import traceback, urllib2, socket, cgi
from ankiqt.ui.utils import saveGeom, restoreGeom, showInfo
from anki.utils import fmtTimeSpan
R_ID = 0
R_USERNAME = 1
R_TITLE = 2
R_DESCRIPTION = 3
R_TAGS = 4
R_VERSION = 5
R_FACTS = 6
R_SIZE = 7
R_COUNT = 8
R_MODIFIED = 9
R_FNAME = 10
class GetShared(QDialog):
def __init__(self, parent, type):
QDialog.__init__(self, parent, Qt.Window)
self.parent = parent
self.form = ankiqt.forms.getshared.Ui_Dialog()
self.form.setupUi(self)
self.ok = True
self.conErrMsg = _("""\
<b>Unable to connect to the server.<br><br>
Please check your network connection or try again in a few minutes.</b><br>
<br>
Error was:<pre>%s</pre>""")
restoreGeom(self, "getshared")
self.setupTable()
self.onChangeType(type)
if type == 0:
self.setWindowTitle(_("Download Shared Deck"))
else:
self.setWindowTitle(_("Download Shared Plugin"))
if self.ok:
self.exec_()
def setupTable(self):
self.connect(
self.form.table, SIGNAL("currentCellChanged(int,int,int,int)"),
self.onCellChanged)
self.form.table.verticalHeader().setDefaultSectionSize(
self.parent.config['editLineSize'])
self.connect(self.form.search, SIGNAL("textChanged(QString)"),
self.limit)
def fetchData(self):
self.parent.setProgressParent(None)
self.parent.startProgress()
self.parent.updateProgress()
try:
socket.setdefaulttimeout(30)
try:
sock = urllib2.urlopen(
"http://anki.ichi2.net/file/search?t=%d" % self.type)
self.allList = simplejson.loads(unicode(sock.read()))
except:
showInfo(self.conErrMsg % cgi.escape(unicode(
traceback.format_exc(), "utf-8", "replace")))
self.close()
self.ok = False
return
finally:
self.parent.finishProgress()
socket.setdefaulttimeout(None)
self.form.search.setFocus()
self.typeChanged()
self.limit()
def limit(self, txt=""):
if not txt:
self.curList = self.allList
else:
txt = unicode(txt).lower()
self.curList = [
l for l in self.allList
if (txt in l[R_TITLE].lower() or
txt in l[R_DESCRIPTION].lower() or
txt in l[R_TAGS].lower())]
self.redraw()
def redraw(self):
self.form.table.setSortingEnabled(False)
self.form.table.setRowCount(len(self.curList))
self.items = {}
if self.type == 0:
cols = (R_TITLE, R_FACTS, R_COUNT, R_MODIFIED)
else:
cols = (R_TITLE, R_COUNT, R_MODIFIED)
for rc, r in enumerate(self.curList):
for cc, c in enumerate(cols):
if c == R_FACTS or c == R_COUNT:
txt = unicode("%15d" % r[c])
elif c == R_MODIFIED:
days = int(((time.time() - r[c])/(24*60*60)))
txt = ngettext("%6d day ago", "%6d days ago", days) % days
else:
txt = unicode(r[c])
item = QTableWidgetItem(txt)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.items[item] = r
self.form.table.setItem(rc, cc, item)
self.form.table.setSortingEnabled(True)
if self.type == 0:
self.form.table.sortItems(2, Qt.DescendingOrder)
else:
self.form.table.sortItems(1, Qt.DescendingOrder)
self.form.table.selectRow(0)
self.onCellChanged(None, None, None, None)
def onCellChanged(self, row, col, x, y):
ci = self.form.table.currentItem()
if not ci:
self.form.bottomLabel.setText(_("Nothing selected."))
return
r = self.items[ci]
self.curRow = r
self.form.bottomLabel.setText(_("""\
<b>Title</b>: %(title)s<br>
<b>Tags</b>: %(tags)s<br>
<b>Size</b>: %(size)0.2fKB<br>
<b>Uploader</b>: %(author)s<br>
<b>Downloads</b>: %(count)s<br>
<b>Modified</b>: %(mod)s ago<br>
<br>%(description)s""") % {
'title': r[R_TITLE],
'tags': r[R_TAGS],
'size': r[R_SIZE] / 1024.0,
'author': r[R_USERNAME],
'count': r[R_COUNT],
'mod': fmtTimeSpan(time.time() - r[R_MODIFIED]),
'description': r[R_DESCRIPTION].replace("\n", "<br>"),
})
self.form.scrollAreaWidgetContents.adjustSize()
self.form.scrollArea.setWidget(self.form.scrollAreaWidgetContents)
def onChangeType(self, type):
self.type = type
self.fetchData()
def typeChanged(self):
self.form.table.clear()
if self.type == 0:
self.form.table.setColumnCount(4)
self.form.table.setHorizontalHeaderLabels([
_("Title"), _("Facts"), _("Downloads"), _("Modified")])
else:
self.form.table.setColumnCount(3)
self.form.table.setHorizontalHeaderLabels([
_("Title"), _("Downloads"), _("Modified")])
self.form.table.horizontalHeader().setResizeMode(
0, QHeaderView.Stretch)
self.form.table.verticalHeader().hide()
def accept(self):
if self.type == 0:
if not self.parent.saveAndClose(hideWelcome=True, parent=self):
return QDialog.accept(self)
(fd, tmpname) = tempfile.mkstemp(prefix="anki")
tmpfile = os.fdopen(fd, "w+b")
cnt = 0
try:
socket.setdefaulttimeout(30)
self.parent.setProgressParent(self)
self.parent.startProgress()
self.parent.updateProgress()
try:
sock = urllib2.urlopen(
"http://anki.ichi2.net/file/get?id=%d" %
self.curRow[R_ID])
while 1:
data = sock.read(32768)
if not data:
break
cnt += len(data)
tmpfile.write(data)
self.parent.updateProgress(
label=_("Downloaded %dKB") % (cnt/1024.0))
except:
showInfo(self.conErrMsg % cgi.escape(unicode(
traceback.format_exc(), "utf-8", "replace")))
self.close()
return
finally:
socket.setdefaulttimeout(None)
self.parent.setProgressParent(None)
self.parent.finishProgress()
QDialog.accept(self)
# file is fetched
tmpfile.seek(0)
self.handleFile(tmpfile)
QDialog.accept(self)
def handleFile(self, file):
ext = os.path.splitext(self.curRow[R_FNAME])[1]
if ext == ".zip":
z = zipfile.ZipFile(file)
else:
z = None
tit = self.curRow[R_TITLE]
tit = re.sub("[^][A-Za-z0-9 ()\-]", "", tit)
tit = tit[0:40]
if self.type == 0:
# deck
dd = self.parent.documentDir
p = os.path.join(dd, tit + ".anki")
if os.path.exists(p):
tit += "%d" % time.time()
for l in z.namelist():
if l == "shared.anki":
dpath = os.path.join(dd, tit + ".anki")
open(dpath, "wb").write(z.read(l))
elif l.startswith("shared.media/"):
try:
os.mkdir(os.path.join(dd, tit + ".media"))
except OSError:
pass
open(os.path.join(dd, tit + ".media",
os.path.basename(l)),"wb").write(z.read(l))
self.parent.loadDeck(dpath)
else:
pd = self.parent.pluginsFolder()
if z:
for l in z.infolist():
try:
os.makedirs(os.path.join(
pd, os.path.dirname(l.filename)))
except OSError:
pass
if l.filename.endswith("/"):
# directory
continue
path = os.path.join(pd, l.filename)
open(path, "wb").write(z.read(l.filename))
else:
open(os.path.join(pd, tit + ext), "wb").write(file.read())
showInfo(_("Plugin downloaded. Please restart Anki."),
parent=self)
| gpl-3.0 | 2,402,456,029,569,720,300 | 35.197581 | 81 | 0.508745 | false |
captiosus/treadmill | treadmill/supervisor/__init__.py | 1 | 16553 | """Supervisor definition anc control.
Linux:
Manages daemontools-like services inside the container.
For each application container there may be multiple services defined, which
are controlled by skarnet.org s6 supervision suite.
Application container is started in chrooted environment, and the root
directory structure::
/
/services/
foo/
bar/
Application container is started with the supervisor monitoring the services
directory using 'svscan /services'. The svscan become the container 'init' -
parent to all processes inside container.
Treadmill will put svscan inside relevant cgroup hierarchy and subsystems.
Once started, services are added by created subdirectory for each service.
The following files are created in each directory:
- run
- app.sh
The run file is executed by s6-supervise. The run file will perform the
following actions:
- setuidgid - change execution context to the proid
- softlimit - part of the suite, set process limits
- setlock ../../<app.name> - this will create a lock monitored by Treadmill,
so that Treadmill is notified when the app exits.
- exec app.sh
All services will be started by Treadmill runtime using 's6-svc' utility. Each
service will be started with 'svc -o' (run once) option, and Treadmill will
be responsible for restart and maintaining restart count.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import json
import os
import logging
import time
import enum
import jinja2
import six
if six.PY2 and os.name == 'posix':
import subprocess32 as subprocess # pylint: disable=import-error
else:
import subprocess # pylint: disable=wrong-import-order
from treadmill import fs
from treadmill import utils
from treadmill import subproc
from . import _service_base
from . import _utils as supervisor_utils
if os.name == 'nt':
from . import winss as sup_impl
_PREFIX = 'winss'
else:
# Disable C0411: standard import "import pwd" comes before "import enum"
import pwd # pylint: disable=C0411
from . import s6 as sup_impl
_PREFIX = 's6'
_LOGGER = logging.getLogger(__name__)
JINJA2_ENV = jinja2.Environment(loader=jinja2.PackageLoader(__name__))
# svc exits 111 if it cannot send a command.
ERR_COMMAND = 111
# svc exits 100 if no supervise process is running on servicedir.
ERR_NO_SUP = 100
POLICY_JSON = 'policy.json'
TRACE_FILE = 'trace'
def open_service(service_dir, existing=True):
"""Open a service object from a service directory.
:param ``str`` service_dir:
Location of the service to open.
:param ``bool`` existing:
Whether the service must already exist
:returns ``_service_base.Service``:
Instance of a service
"""
if not isinstance(service_dir, _service_base.Service):
svc_data = _service_base.Service.read_dir(
service_dir
)
if svc_data is None:
if existing:
raise ValueError('Invalid Service directory: %r' % service_dir)
else:
svc_type = _service_base.ServiceType.LongRun
svc_basedir = os.path.dirname(service_dir)
svc_name = os.path.basename(service_dir)
else:
svc_type, svc_basedir, svc_name = svc_data
return sup_impl.create_service(
svc_basedir=svc_basedir,
svc_name=svc_name,
svc_type=svc_type
)
return service_dir
def _create_scan_dir_s6(scan_dir, finish_timeout, monitor_service=None):
"""Create a scan directory.
:param ``str`` scan_dir:
Location of the scan directory.
:param ``int`` finish_timeout:
The finish script timeout.
:param ``str`` monitor_service:
Service monitoring other services in this scan directory.
:returns ``_service_dir_base.ServiceDirBase``:
Instance of a service dir
"""
if not isinstance(scan_dir, sup_impl.ScanDir):
scan_dir = sup_impl.ScanDir(scan_dir)
svscan_finish_script = utils.generate_template(
's6.svscan.finish',
timeout=finish_timeout,
_alias=subproc.get_aliases()
)
scan_dir.finish = svscan_finish_script
svscan_sigterm_script = utils.generate_template(
's6.svscan.sigterm',
monitor_service=monitor_service,
_alias=subproc.get_aliases()
)
scan_dir.sigterm = svscan_sigterm_script
svscan_sighup_script = utils.generate_template(
's6.svscan.sighup',
monitor_service=monitor_service,
_alias=subproc.get_aliases()
)
scan_dir.sighup = svscan_sighup_script
svscan_sigint_script = utils.generate_template(
's6.svscan.sigint',
monitor_service=monitor_service,
_alias=subproc.get_aliases()
)
scan_dir.sigint = svscan_sigint_script
svscan_sigquit_script = utils.generate_template(
's6.svscan.sigquit',
monitor_service=monitor_service,
_alias=subproc.get_aliases()
)
scan_dir.sigquit = svscan_sigquit_script
return scan_dir
def _create_scan_dir_winss(scan_dir, finish_timeout):
"""Create a scan directory.
:param ``str`` scan_dir:
Location of the scan directory.
:param ``int`` finish_timeout:
The finish script timeout.
:returns ``_service_dir_base.ServiceDirBase``:
Instance of a service dir
"""
if not isinstance(scan_dir, sup_impl.ScanDir):
scan_dir = sup_impl.ScanDir(scan_dir)
svscan_finish_script = utils.generate_template(
'winss.svscan.finish',
timeout=finish_timeout,
scan_dir=scan_dir.directory,
_alias=subproc.get_aliases()
)
scan_dir.finish = svscan_finish_script
return scan_dir
# Disable C0103: Invalid constant name "create_service"
# pylint: disable=C0103
if _PREFIX == 'winss':
create_scan_dir = _create_scan_dir_winss
else:
create_scan_dir = _create_scan_dir_s6
def create_environ_dir(env_dir, env, update=False):
"""Create/update environment directory for the supervisor.
"""
fs.mkdir_safe(env_dir)
supervisor_utils.environ_dir_write(
env_dir, env,
update=update
)
# Disable W0613: Unused argument 'kwargs' (for s6/winss compatibility)
# pylint: disable=W0613
def _create_service_s6(base_dir,
name,
app_run_script,
userid='root',
downed=False,
environ_dir=None,
environ=None,
environment='prod',
monitor_policy=None,
trace=None,
timeout_finish=None,
run_script='s6.run',
log_run_script='s6.logger.run',
finish_script='s6.finish',
**kwargs):
"""Initializes service directory.
Creates run, finish scripts as well as log directory with appropriate
run script.
"""
try:
user_pw = pwd.getpwnam(userid)
except KeyError:
# Check the identity we are going to run as. It needs to exists on the
# host or we will fail later on as we try to seteuid.
_LOGGER.exception('Unable to find userid %r in passwd database.',
userid)
raise
if isinstance(base_dir, sup_impl.ScanDir):
# We are given a scandir as base, use it.
svc = base_dir.add_service(name, _service_base.ServiceType.LongRun)
else:
svc = LongrunService(base_dir, name)
# Setup the environ
if environ is None:
svc_environ = {}
else:
svc_environ = environ.copy()
svc_environ['HOME'] = user_pw.pw_dir
svc.environ = svc_environ
if environment == 'prod':
ionice_prio = 5
else:
ionice_prio = 6
monitored = (monitor_policy is not None)
# Setup the run script
svc.run_script = utils.generate_template(
run_script,
user=userid,
shell=user_pw.pw_shell,
environ_dir=environ_dir,
monitored=monitored,
ionice_prio=ionice_prio,
_alias=subproc.get_aliases()
)
# Setup the finish script
svc.finish_script = utils.generate_template(
finish_script,
_alias=subproc.get_aliases()
)
# Setup the log run script
svc.log_run_script = utils.generate_template(
log_run_script,
logdir=os.path.relpath(
os.path.join(svc.data_dir, 'log'),
svc.logger_dir
),
_alias=subproc.get_aliases()
)
svc.default_down = bool(downed)
if monitored:
svc.timeout_finish = 0
else:
svc.timeout_finish = timeout_finish
svc.write()
# Write the app_start script
supervisor_utils.script_write(
os.path.join(svc.data_dir, 'app_start'),
app_run_script
)
# Optionally write a monitor policy file
_LOGGER.info('monitor_policy, %r', monitor_policy)
if monitor_policy is not None:
supervisor_utils.data_write(
os.path.join(svc.data_dir, POLICY_JSON),
json.dumps(monitor_policy)
)
# Optionally write trace information file
if trace is not None:
supervisor_utils.data_write(
os.path.join(svc.data_dir, TRACE_FILE),
json.dumps(trace)
)
return svc
# Disable W0613: Unused argument 'kwargs' (for s6/winss compatibility)
# pylint: disable=W0613
def _create_service_winss(base_dir,
name,
app_run_script,
downed=False,
environ=None,
monitor_policy=None,
timeout_finish=None,
run_script='winss.run',
log_run_script='winss.logger.run',
finish_script='winss.finish',
**kwargs):
"""Initializes service directory.
Creates run, finish scripts as well as log directory with appropriate
run script.
"""
if isinstance(base_dir, sup_impl.ScanDir):
# We are given a scandir as base, use it.
svc = base_dir.add_service(name, _service_base.ServiceType.LongRun)
else:
svc = LongrunService(base_dir, name)
# Setup the environ
if environ is None:
svc_environ = {}
else:
svc_environ = environ.copy()
svc.environ = svc_environ
monitored = (monitor_policy is not None)
# Setup the run script
svc.run_script = utils.generate_template(
run_script,
app_run_script=app_run_script,
_alias=subproc.get_aliases()
)
# Setup the finish script
svc.finish_script = utils.generate_template(
finish_script,
_alias=subproc.get_aliases()
)
logdir = os.path.join(svc.data_dir, 'log')
fs.mkdir_safe(logdir)
# Setup the log run script
svc.log_run_script = utils.generate_template(
log_run_script,
logdir=os.path.relpath(
logdir,
svc.logger_dir
),
_alias=subproc.get_aliases()
)
svc.default_down = bool(downed)
if monitored:
svc.timeout_finish = 0
else:
svc.timeout_finish = timeout_finish
svc.write()
# Optionally write a monitor policy file
if monitor_policy is not None:
supervisor_utils.data_write(
os.path.join(svc.data_dir, POLICY_JSON),
json.dumps(monitor_policy)
)
return svc
# Disable C0103: Invalid constant name "create_service"
# pylint: disable=C0103
if _PREFIX == 'winss':
create_service = _create_service_winss
else:
create_service = _create_service_s6
class ServiceWaitAction(enum.Enum):
"""Enumeration of wait actions."""
# pylint complains: Invalid class attribute name "up"
up = 'u' # pylint: disable=C0103
down = 'd'
really_up = 'U'
really_down = 'D'
class ServiceControlAction(enum.Enum):
"""Enumeration of control actions."""
kill = 'k'
once = 'o'
once_at_most = 'O'
down = 'd'
# pylint complains: Invalid class attribute name "up"
up = 'u' # pylint: disable=C0103
exit = 'x'
class SvscanControlAction(enum.Enum):
"""Enumeration of control actions."""
alarm = 'a'
abort = 'b'
nuke = 'n'
quit = 'q'
exit = 'x'
def _get_cmd(cmd):
return _PREFIX + '_' + cmd
def _get_wait_action(action):
if os.name == 'nt' and action == ServiceWaitAction.really_up:
action = ServiceWaitAction.up
return action
def is_supervised(service_dir):
"""Checks if the supervisor is running."""
try:
subproc.check_call([_get_cmd('svok'), service_dir])
return True
except subprocess.CalledProcessError as err:
# svok returns 1 when the service directory is not supervised.
if err.returncode == 1:
return False
else:
raise
def control_service(service_dir, actions, wait=None, timeout=0):
"""Sends a control signal to the supervised process."""
cmd = [_get_cmd('svc')]
if wait:
cmd.append('-w' + _get_wait_action(wait).value)
if timeout > 0:
cmd.extend(['-T{}'.format(timeout)])
action_str = '-'
for action in utils.get_iterable(actions):
action_str += action.value
cmd.append(action_str)
cmd.append(service_dir)
try:
subproc.check_call(cmd)
return True
except subprocess.CalledProcessError as err:
# svc returns 1 on timeout.
if err.returncode == 1:
return False
else:
raise
def control_svscan(scan_dir, actions):
"""Sends a control signal to a svscan instance."""
action_str = '-'
for action in utils.get_iterable(actions):
action_str += action.value
subproc.check_call([_get_cmd('svscanctl'), action_str, scan_dir])
def wait_service(service_dirs, action, all_services=True, timeout=0):
"""Performs a wait task on the given list of service directories."""
cmd = [_get_cmd('svwait')]
if timeout > 0:
cmd.extend(['-t{}'.format(timeout)])
if not all_services:
cmd.append('-o')
cmd.append('-' + _get_wait_action(action).value)
cmd.extend(utils.get_iterable(service_dirs))
try:
subproc.check_call(cmd)
return True
except subprocess.CalledProcessError as err:
# old svwait returns 1 and new svwait returns 99 on timeout.
if err.returncode in (1, 99):
return False
else:
raise
def ensure_not_supervised(service_dir):
"""Waits for the service and log service to not be supervised."""
service_dirs = []
if is_supervised(service_dir):
service_dirs.append(service_dir)
log_dir = os.path.join(service_dir, 'log')
if os.path.exists(log_dir) and is_supervised(log_dir):
service_dirs.append(log_dir)
for service in service_dirs:
try:
# Kill and close supervised process as it should have already
# been told to go down
control_service(service, (ServiceControlAction.kill,
ServiceControlAction.exit),
ServiceWaitAction.really_down,
timeout=1000)
except subprocess.CalledProcessError:
# Ignore this as supervisor may be down
pass
count = 0
while is_supervised(service):
count += 1
if count == 50:
raise Exception(
'Service dir {0} failed to stop in a reasonable time.'
.format(service)
)
time.sleep(0.1)
ScanDir = sup_impl.ScanDir
LongrunService = sup_impl.LongrunService
ServiceType = _service_base.ServiceType
__all__ = [
'ScanDir',
'LongrunService',
'ServiceType',
'ERR_COMMAND',
'ERR_NO_SUP',
'POLICY_JSON',
'TRACE_FILE',
'create_environ_dir',
'ServiceWaitAction',
'ServiceControlAction',
'SvscanControlAction',
'open_service',
'create_scan_dir',
'create_service',
'is_supervised',
'control_service',
'control_svscan',
'wait_service',
]
if _PREFIX == 's6':
BundleService = sup_impl.BundleService
OneshotService = sup_impl.OneshotService
__all__ += [
'BundleService',
'OneshotService',
]
| apache-2.0 | -1,955,057,397,741,377,800 | 27.103565 | 79 | 0.61137 | false |
warp1337/opencv_facerecognizer | src/ocvfacerec/facerec/operators.py | 1 | 5486 | # Copyright (c) 2015.
# Philipp Wagner <bytefish[at]gmx[dot]de> and
# Florian Lier <flier[at]techfak.uni-bielefeld.de> and
# Norman Koester <nkoester[at]techfak.uni-bielefeld.de>
#
#
# Released to public domain under terms of the BSD Simplified license.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the organization nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# See <http://www.opensource.org/licenses/bsd-license>
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import numpy as np
from ocvfacerec.facerec.feature import AbstractFeature
class FeatureOperator(AbstractFeature):
"""
A FeatureOperator operates on two feature models.
Args:
model1 [AbstractFeature]
model2 [AbstractFeature]
"""
def __init__(self, model1, model2):
if (not isinstance(model1, AbstractFeature)) or (not isinstance(model2, AbstractFeature)):
raise Exception("A FeatureOperator only works on classes implementing an AbstractFeature!")
self.model1 = model1
self.model2 = model2
def __repr__(self):
return "FeatureOperator(" + repr(self.model1) + "," + repr(self.model2) + ")"
class ChainOperator(FeatureOperator):
"""
The ChainOperator chains two feature extraction modules:
model2.compute(model1.compute(X,y),y)
Where X can be generic input data.
Args:
model1 [AbstractFeature]
model2 [AbstractFeature]
"""
def __init__(self, model1, model2):
FeatureOperator.__init__(self, model1, model2)
def compute(self, X, y):
X = self.model1.compute(X, y)
return self.model2.compute(X, y)
def extract(self, X):
X = self.model1.extract(X)
return self.model2.extract(X)
def __repr__(self):
return "ChainOperator(" + repr(self.model1) + "," + repr(self.model2) + ")"
class CombineOperator(FeatureOperator):
"""
The CombineOperator combines the output of two feature extraction modules as:
(model1.compute(X,y),model2.compute(X,y))
, where the output of each feature is a [1xN] or [Nx1] feature vector.
Args:
model1 [AbstractFeature]
model2 [AbstractFeature]
"""
def __init__(self, model1, model2):
FeatureOperator.__init__(self, model1, model2)
def compute(self, X, y):
A = self.model1.compute(X, y)
B = self.model2.compute(X, y)
C = []
for i in range(0, len(A)):
ai = np.asarray(A[i]).reshape(1, -1)
bi = np.asarray(B[i]).reshape(1, -1)
C.append(np.hstack((ai, bi)))
return C
def extract(self, X):
ai = self.model1.extract(X)
bi = self.model2.extract(X)
ai = np.asarray(ai).reshape(1, -1)
bi = np.asarray(bi).reshape(1, -1)
return np.hstack((ai, bi))
def __repr__(self):
return "CombineOperator(" + repr(self.model1) + "," + repr(self.model2) + ")"
class CombineOperatorND(FeatureOperator):
"""
The CombineOperator combines the output of two multidimensional feature extraction modules.
(model1.compute(X,y),model2.compute(X,y))
Args:
model1 [AbstractFeature]
model2 [AbstractFeature]
hstack [bool] stacks data horizontally if True and vertically if False
"""
def __init__(self, model1, model2, hstack=True):
FeatureOperator.__init__(self, model1, model2)
self._hstack = hstack
def compute(self, X, y):
A = self.model1.compute(X, y)
B = self.model2.compute(X, y)
C = []
for i in range(0, len(A)):
if self._hstack:
C.append(np.hstack((A[i], B[i])))
else:
C.append(np.vstack((A[i], B[i])))
return C
def extract(self, X):
ai = self.model1.extract(X)
bi = self.model2.extract(X)
if self._hstack:
return np.hstack((ai, bi))
return np.vstack((ai, bi))
def __repr__(self):
return "CombineOperatorND(" + repr(self.model1) + "," + repr(self.model2) + ", hstack=" + str(
self._hstack) + ")"
| bsd-3-clause | 1,871,205,741,122,541,000 | 33.942675 | 103 | 0.642362 | false |
AstroTech/workshop-python | _book/conf.py | 1 | 3091 | author = 'Matt Harasymczuk'
email = '[email protected]'
project = 'Python 3: from None to Machine Learning'
description = "Matt Harasymczuk's Python 3: from None to Machine Learning"
extensions = [
'sphinx.ext.doctest',
'sphinx.ext.todo',
'sphinx.ext.imgmath',
# 'sphinx.ext.autosectionlabel',
# 'sphinx.ext.viewcode',
# 'sphinx.ext.coverage',
# 'sphinx.ext.githubpages',
# 'sphinx.ext.autodoc',
# 'sphinx.ext.intersphinx',
# 'sphinx.ext.graphviz',
'nbsphinx',
'sphinxcontrib.bibtex',
# 'sphinxjp.themes.revealjs',
'IPython.sphinxext.ipython_console_highlighting',
]
todo_emit_warnings = False
todo_include_todos = True
html_theme = 'sphinx_rtd_theme'
language = 'en'
numfig_format = {
'section': 'Sect. %s.',
'figure': 'Fig. %s.',
'table': 'Tab. %s.',
'code-block': 'Code Listing %s.',
}
# -----------------------------------------------------------------------------
# Standard book config
# -----------------------------------------------------------------------------
import datetime
import os
import re
import subprocess
import sys
source_directory = 'book'
highlight_language = 'python3'
pygments_style = 'borland'
numfig = True
templates_path = ['_templates']
master_doc = 'index'
source_suffix = ['.rst']
imgmath_image_format = 'svg'
today_fmt = '%Y-%m-%d'
project_slug = re.sub(r'[\W]+', '', project)
sha1 = subprocess.Popen('git log -1 --format="%h"', stdout=subprocess.PIPE, shell=True).stdout.read().decode().replace('\n', '')
version = '#{sha1}, {date:%Y-%m-%d}'.format(sha1=sha1, date=datetime.date.today())
release = '#{sha1}, {date:%Y-%m-%d}'.format(sha1=sha1, date=datetime.date.today())
copyright = '{year}, {author} <{email}>'.format(
year=datetime.date.today().year,
author=author,
email=email,
)
exclude_patterns = [
'about/assignment/*.rst',
'_build', '.build',
'_tmp',
'**/contrib',
'_themes',
'**.ipynb_checkpoints',
'_static',
'*/_template.rst',
'.*', 'venv*', 'virtualenv*',
'index-*.rst',
]
extensions_dir = os.path.join(os.path.dirname(__file__), '', '_extensions')
sys.path.append(extensions_dir)
html_theme_path = ['_themes']
html_static_path = ['_static']
html_favicon = '_static/favicon.png'
html_sidebars = {'sidebar': ['localtoc.html', 'sourcelink.html', 'searchbox.html']}
html_show_sphinx = False
htmlhelp_basename = project
latex_documents = [(master_doc, '{0}.tex'.format(project_slug), project, author, 'manual')]
latex_elements = {
'papersize': 'a4paper',
'pointsize': '10pt',
'figure_align': 'htbp',
# Fix for: LaTeX Backend Fails with Citations In Figure Captions
'preamble': r"""
\usepackage{etoolbox}
\AtBeginEnvironment{figure}{\renewcommand{\phantomsection}{}}
"""
}
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright
epub_exclude_files = ['search.html']
man_pages = [
(master_doc, project_slug, project, [author], 1)
]
texinfo_documents = [
(master_doc, project_slug, project, author, project, '', 'Miscellaneous'),
]
| mit | 2,576,808,613,306,298,400 | 26.598214 | 128 | 0.612423 | false |
TheCoSMoCompany/biopredyn | Prototype/src/libsbml-5.10.0/examples/python/validateSBML.py | 1 | 6406 | #!/usr/bin/env python
##
## @file validateSBML.py
## @brief Validates one or more SBML files
## @author Akiya Jouraku (translated from libSBML C++ examples)
## @author Ben Bornstein
## @author Michael Hucka
##
## <!--------------------------------------------------------------------------
## This sample program is distributed under a different license than the rest
## of libSBML. This program uses the open-source MIT license, as follows:
##
## Copyright (c) 2013-2014 by the California Institute of Technology
## (California, USA), the European Bioinformatics Institute (EMBL-EBI, UK)
## and the University of Heidelberg (Germany), with support from the National
## Institutes of Health (USA) under grant R01GM070923. All rights reserved.
##
## Permission is hereby granted, free of charge, to any person obtaining a
## copy of this software and associated documentation files (the "Software"),
## to deal in the Software without restriction, including without limitation
## the rights to use, copy, modify, merge, publish, 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.
##
## Neither the name of the California Institute of Technology (Caltech), nor
## of the European Bioinformatics Institute (EMBL-EBI), nor of the University
## of Heidelberg, nor the names of any contributors, may be used to endorse
## or promote products derived from this software without specific prior
## written permission.
## ------------------------------------------------------------------------ -->
import sys
import os.path
import time
import libsbml
class validateSBML:
def __init__(self, ucheck):
self.reader = libsbml.SBMLReader()
self.ucheck = ucheck
self.numinvalid = 0
def validate(self, file):
if not os.path.exists(file):
print("[Error] %s : No such file." % (infile))
self.numinvalid += 1
return
start = time.time()
sbmlDoc = libsbml.readSBML(file)
stop = time.time()
timeRead = (stop - start)*1000
errors = sbmlDoc.getNumErrors()
seriousErrors = False
numReadErr = 0
numReadWarn = 0
errMsgRead = ""
if errors > 0:
for i in range(errors):
severity = sbmlDoc.getError(i).getSeverity()
if (severity == libsbml.LIBSBML_SEV_ERROR) or (severity == libsbml.LIBSBML_SEV_FATAL):
seriousErrors = True
numReadErr += 1
else:
numReadWarn += 1
errMsgRead = sbmlDoc.getErrorLog().toString()
# If serious errors are encountered while reading an SBML document, it
# does not make sense to go on and do full consistency checking because
# the model may be nonsense in the first place.
numCCErr = 0
numCCWarn = 0
errMsgCC = ""
skipCC = False;
timeCC = 0.0
if seriousErrors:
skipCC = True;
errMsgRead += "Further consistency checking and validation aborted."
self.numinvalid += 1;
else:
sbmlDoc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY, self.ucheck)
start = time.time()
failures = sbmlDoc.checkConsistency()
stop = time.time()
timeCC = (stop - start)*1000
if failures > 0:
isinvalid = False;
for i in range(failures):
severity = sbmlDoc.getError(i).getSeverity()
if (severity == libsbml.LIBSBML_SEV_ERROR) or (severity == libsbml.LIBSBML_SEV_FATAL):
numCCErr += 1
isinvalid = True;
else:
numCCWarn += 1
if isinvalid:
self.numinvalid += 1;
errMsgCC = sbmlDoc.getErrorLog().toString()
#
# print results
#
print(" filename : %s" % (file))
print(" file size (byte) : %d" % (os.path.getsize(file)))
print(" read time (ms) : %f" % (timeRead))
if not skipCC :
print( " c-check time (ms) : %f" % (timeCC))
else:
print( " c-check time (ms) : skipped")
print( " validation error(s) : %d" % (numReadErr + numCCErr))
if not skipCC :
print( " (consistency error(s)): %d" % (numCCErr))
else:
print( " (consistency error(s)): skipped")
print( " validation warning(s) : %d" % (numReadWarn + numCCWarn))
if not skipCC :
print( " (consistency warning(s)): %d" % (numCCWarn))
else:
print( " (consistency warning(s)): skipped")
if errMsgRead or errMsgCC:
print()
print( "===== validation error/warning messages =====\n")
if errMsgRead :
print( errMsgRead)
if errMsgCC :
print( "*** consistency check ***\n")
print( errMsgCC)
def main (args):
"""usage: validateSBML.py [-u] inputfile1 [inputfile2 ...]
-u skips unit consistency check
"""
if len(args) < 2:
print( main.__doc__)
sys.exit(1)
elif (len(args) == 1) and (args[1] == "-u"):
print( main.__doc__)
sys.exit(1)
enableUnitCCheck = True
if args[1] == "-u":
enableUnitCCheck = False
validator = validateSBML(enableUnitCCheck)
fnum = 0
for i in range(1,len(args)):
if args[i] == "-u":
continue
print( "---------------------------------------------------------------------------")
validator.validate(args[i])
fnum += 1
numinvalid = validator.numinvalid
print( "---------------------------------------------------------------------------")
print( "Validated %d files, %d valid files, %d invalid files" % (fnum, fnum - numinvalid, numinvalid))
if not enableUnitCCheck:
print( "(Unit consistency checks skipped)")
if numinvalid > 0:
sys.exit(1)
if __name__ == '__main__':
main(sys.argv)
| bsd-3-clause | -5,608,578,717,612,800,000 | 31.683673 | 104 | 0.604277 | false |
huaxz1986/git_book | chapters/Kaggle/grid_search.py | 1 | 1955 | import scipy
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import classification_report
from data_clean import current_time
from sklearn.model_selection import train_test_split
from data_preprocess import Data_Preprocesser,Data_Cleaner
def grid_search(tuned_parameters,data,train_size,seed):
'''
参数优化
:param tuned_parameters: 待优化的参数字典
:param data: 数据集
:param train_size:训练集大小
:param seed:用于生成随机数种子
:return:
'''
print("----- Begin run grid_search at %s -------"%current_time())
X=data[:,:-1]
y=data[:,-1]
X_train,X_test,y_train,y_test=train_test_split(X,y,train_size=train_size,stratify=data[:,-1],random_state=seed)
clf=GridSearchCV(GradientBoostingClassifier(),tuned_parameters,cv=10,scoring="roc_auc")
clf.fit(X_train,y_train)
print("Best parameters set found:",clf.best_params_)
print("Randomized Grid scores:")
for params, mean_score, scores in clf.grid_scores_:
print("\t%0.3f (+/-%0.03f) for %s" % (mean_score, scores.std() * 2, params))
print("Optimized Score:",clf.score(X_test,y_test))
print("Detailed classification report:")
y_true, y_pred = y_test, clf.predict(X_test)
print(classification_report(y_true, y_pred))
print("----- End run grid_search at %s -------"%current_time())
if __name__=='__main__':
clearner=Data_Cleaner("./data/people.csv",'./data/act_train.csv','./data/act_test.csv')
result=clearner.load_data()
preprocessor=Data_Preprocesser(*result)
train_datas,test_datas=preprocessor.load_data()
tuned_parameters={'subsample':[0.3,0.35,0.4,0.45,0.5,0.55,0.6],
'n_estimators':[30,35,50,100,150,200]
,
'max_depth':[2,4,8,16,32]}
grid_search(tuned_parameters,train_datas['type 7'],train_size=0.75,seed=0) | gpl-3.0 | -9,070,638,557,172,177,000 | 41.177778 | 115 | 0.659989 | false |
thousandparsec-obsolete/libmng-py | mngdisplay.py | 1 | 1428 | """\
mngdisplay.py <options> <filename>
Tries to displays a mng using a different options.
-t sdl Use pygame (ctypes of C version)
-t pygame Alias of the above
-t pygameC Use the C version of pygame
-t pygameT Use the ctypes version of pygame
-t wx Use wx
"""
def main(argv):
import sys
type = None
for i in range(0, len(argv)):
arg = argv[i]
if arg == "-t":
type = argv[i+1]
break
while type == None:
# Try for pygame
try:
import pygame
type = "pygame"
break
except ImportError, e:
pass
# O well, maybe wx?
try:
import wx
type = "wx"
break
except ImportError, e:
pass
break
if type == "sdl":
type = "pygame"
print type
if type == "pygame":
import pygame
screen = pygame.display.set_mode((600, 600), 0, 16)
from mng.pygame import MNG
def input(events):
for event in events:
if event.type == pygame.QUIT:
sys.exit(0)
else:
print event
s = pygame.Surface((1,1)).convert_alpha()
a = MNG(argv[-1], s)
a.play()
while True:
screen.fill((0,255,0))
delay, image = a.nextframe()
screen.blit(image, (0,0))
pygame.display.flip()
input(pygame.event.get())
import sys
if __name__ == "__main__":
argv = list(sys.argv)
if argv[1] == "-p":
del argv[1]
print "Profile..."
import hotshot
prof = hotshot.Profile("hotshot_stats")
prof.runcall(main, argv)
prof.close()
else:
main(argv)
| lgpl-2.1 | 7,213,422,322,001,718,000 | 16 | 54 | 0.611345 | false |
BarraQDA/nvivotools | nvpn2nvp.py | 1 | 6639 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2020 Jonathan Schultz
#
# 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 argrecord import ArgumentHelper, ArgumentRecorder
import argparse
import NVivo
from mssqlTools import mssqlAPI
import os
import sys
import shutil
import subprocess
import tempfile
def DenormaliseNVP(arglist):
parser = ArgumentRecorder(description='Create an NVivo for Mac file from a normalised SQLite file.')
parser.add_argument('-nv', '--nvivoversion', choices=["10", "11"], default="10",
help='NVivo version (10 or 11)')
parser.add_argument('-S', '--server', type=str,
help="IP address/name of Microsoft SQL Server")
parser.add_argument('-P', '--port', type=int,
help="Port of Microsoft SQL Server")
parser.add_argument('-i', '--instance', type=str,
help="Microsoft SQL Server instance")
parser.add_argument('-U', '--sshuser', type=str,
help="User name for ssh connections to server")
parser.add_argument('-u', '--users', choices=["skip", "merge", "overwrite", "replace"], default="merge",
help='User action.')
parser.add_argument('-p', '--project', choices=["skip", "overwrite"], default="overwrite",
help='Project action.')
parser.add_argument('-nc', '--node-categories', choices=["skip", "merge", "overwrite"], default="merge",
help='Node category action.')
parser.add_argument('-n', '--nodes', choices=["skip", "merge"], default="merge",
help='Node action.')
parser.add_argument('-na', '--node-attributes', choices=["skip", "merge", "overwrite"], default="merge",
help='Node attribute table action.')
parser.add_argument('-sc', '--source-categories', choices=["skip", "merge", "overwrite"], default="merge",
help='Source category action.')
parser.add_argument('--sources', choices=["skip", "merge", "overwrite"], default="merge",
help='Source action.')
parser.add_argument('-sa', '--source-attributes', choices=["skip", "merge", "overwrite"], default="merge",
help='Source attribute action.')
parser.add_argument('-t', '--taggings', choices=["skip", "merge"], default="merge",
help='Tagging action.')
parser.add_argument('-a', '--annotations', choices=["skip", "merge"], default="merge",
help='Annotation action.')
parser.add_argument('-b', '--base', dest='basefile', type=argparse.FileType('rb'), nargs='?',
help="Base NVP file to insert into")
parser.add_argument('-v', '--verbosity', type=int, default=1, private=True)
parser.add_argument('--logfile', type=str, help="Logfile, default is <outfile>.log",
private=True)
parser.add_argument('--no-logfile', action='store_true', help='Do not output a logfile')
parser.add_argument('infile', type=str, input=True,
help="Input normalised SQLite (.nvpn) file")
parser.add_argument('outfile', type=str, nargs='?', output=True,
help="Output NVivo for Windows (.nvp) file or directory; default is <infile>.nvp")
args = parser.parse_args(arglist)
# Function to execute a command either locally or remotely
def executecommand(command):
if not args.server: # ie server is on same machine as this script
return subprocess.check_output(command, text=True).strip()
else:
print(['ssh', ((args.sshuser + '@') if args.sshuser else '') + args.server] + [('"' + word + '"') if ' ' in word else word for word in command])
# This quoting of arguments is a bit of a hack but seems to work
return subprocess.check_output(['ssh', ((args.sshuser + '@') if args.sshuser else '') + args.server] + [('"' + word + '"') if ' ' in word else word for word in command], text=True).strip()
if args.outfile is None:
args.outfile = args.infile.rsplit('.',1)[0] + '.nvp'
elif os.path.isdir(args.outfile):
args.outfile = os.path.join(args.outfile,
os.path.basename(args.infile.name.rsplit('.',1)[0] + '.nvp'))
if not args.no_logfile:
logfilename = args.outfile.rsplit('.',1)[0] + '.log'
incomments = ArgumentHelper.read_comments(logfilename) or ArgumentHelper.separator()
logfile = open(logfilename, 'w')
parser.write_comments(args, logfile, incomments=incomments)
logfile.close()
# Fill in extra arguments that NVivo module expects
args.mac = False
args.windows = True
if args.basefile is None:
args.basefile = os.path.dirname(os.path.realpath(__file__)) + os.path.sep + ('emptyNVivo10Win.nvp' if args.nvivoversion == '10' else 'emptyNVivo11Win.nvp')
if args.server is None:
if os.name != 'nt':
raise RuntimeError("This does not appear to be a Windows machine so --server must be specified.")
mssqlapi = mssqlAPI(args.server,
user=args.sshuser,
port=args.port,
instance=args.instance,
version = ('MSSQL12' if args.nvivoversion == '11' else 'MSSQL10_50'),
verbosity = args.verbosity)
# Get reasonably distinct yet recognisable DB name
dbname = 'nvivo' + str(os.getpid())
mssqlapi.attach(args.basefile, dbname)
try:
args.indb = 'sqlite:///' + args.infile
args.outdb = 'mssql+pymssql://nvivotools:nvivotools@' + (args.server or 'localhost') + ((':' + str(args.port)) if args.port else '') + '/' + dbname
NVivo.Denormalise(args)
mssqlapi.save(args.outfile, dbname)
except:
raise
finally:
mssqlapi.drop(dbname)
if __name__ == '__main__':
DenormaliseNVP(None)
| gpl-3.0 | 6,203,106,739,478,604,000 | 46.76259 | 200 | 0.602802 | false |
yoon-gu/Mozart | mozart/mesh/triangle.py | 1 | 5353 | import numpy as np
def compute_n4s(n4e):
"""
Get a matrix whose each row contains end points of the corresponding side (or edge)
Paramters
- ``n4e`` (``int32 array``) : nodes for elements
Returns
- ``n4s`` (``int32 array``) : nodes for sides
Example
>>> n4e = np.array([[1, 3, 0], [3, 1, 2]])
>>> n4s = compute_n4s(n4e)
>>> n4s
array([[1, 3],
[3, 0],
[1, 2],
[0, 1],
[2, 3]])
"""
allSides = np.vstack((np.vstack((n4e[:,[0,1]], n4e[:,[1,2]])),n4e[:,[2,0]]))
tmp=np.sort(allSides)
x, y = tmp.T
_, ind = np.unique(x + y*1.0j, return_index=True)
n4sInd = np.sort(ind)
n4s = allSides[n4sInd,:]
return n4s
def compute_s4e(n4e):
"""
Get a matrix whose each row contains three side numbers of the corresponding element
Paramters
- ``n4e`` (``int32 array``) : nodes for elements
Returns
- ``s4e`` (``int32 array``) : sides for elements
Example
>>> n4e = np.array([[1, 3, 0], [3, 1, 2]])
>>> s4e = compute_s4e(n4e)
>>> s4e
array([[0, 1, 3],
[0, 2, 4]])
"""
allSides = np.vstack((np.vstack((n4e[:,[0,1]], n4e[:,[1,2]])),n4e[:,[2,0]]))
tmp=np.sort(allSides)
x, y = tmp.T
_, ind, back = np.unique(x + y*1.0j, return_index=True, return_inverse=True)
sortInd = ind.argsort()
sideNr = np.zeros(ind.size, dtype = int)
sideNr[sortInd] = np.arange(0,ind.size)
s4e = sideNr[back].reshape(3,-1).transpose().astype('int')
return s4e
def compute_e4s(n4e):
"""
Get a matrix whose each row contains two elements sharing the corresponding side
If second column is -1, the corresponding side is on the boundary
Paramters
- ``n4e`` (``int32 array``) : nodes for elements
Returns
- ``e4s`` (``int32 array``) : elements for sides
Example
>>> n4e = np.array([[1, 3, 0], [3, 1, 2]])
>>> e4s = compute_e4s(n4e)
>>> e4s
array([[ 0, 1],
[ 0, -1],
[ 1, -1],
[ 0, -1],
[ 1, -1]])
"""
allSides = np.vstack((np.vstack((n4e[:,[0,1]], n4e[:,[1,2]])),n4e[:,[2,0]]))
tmp=np.sort(allSides)
x, y = tmp.T
_, ind, back = np.unique(x + y*1.0j, return_index=True, return_inverse=True)
n4sInd = np.sort(ind)
nrElems = n4e.shape[0]
elemNumbers = np.hstack((np.hstack((np.arange(0,nrElems),np.arange(0,nrElems))),np.arange(0,nrElems)))
e4s=np.zeros((ind.size,2),int)
e4s[:,0]=elemNumbers[n4sInd] + 1
allElems4s=np.zeros(allSides.shape[0],int)
tmp2 = np.bincount((back + 1),weights = (elemNumbers + 1))
allElems4s[ind]=tmp2[1::]
e4s[:,1] = allElems4s[n4sInd] - e4s[:,0]
e4s=e4s-1
return e4s
def refineUniformRed(c4n, n4e, n4Db, n4Nb):
"""
Refine a given mesh uniformly using the red refinement
Paramters
- ``c4n`` (``float64 array``) : coordinates for elements
- ``n4e`` (``int32 array``) : nodes for elements
- ``n4Db`` (``int32 array``) : nodes for Difichlet boundary
- ``n4Nb`` (``int32 array``) : nodes for Neumann boundary
Returns
- ``c4nNew`` (``float64 array``) : coordinates for element obtained from red refinement
- ``n4eNew`` (``int32 array``) : nodes for element obtained from red refinement
- ``n4DbNew`` (``int32 array``) : nodes for Dirichlet boundary obtained from red refinement
- ``n4NbNew`` (``int32 array``) : nodes for Neumann boundary obtained from red refinement
Example
>>> c4n = np.array([[0., 0.], [1., 0.], [1., 1.], [0., 1.]])
>>> n4e = np.array([[1, 3, 0], [3, 1, 2]])
>>> n4Db = np.array([[0, 1], [1, 2]])
>>> n4Nb = np.array([[2, 3],[3, 0]])
>>> c4nNew, n4eNew, n4DbNew, n4NbNew = refineUniformRed(c4n, n4e, n4Db, n4Nb)
>>> c4nNew
array([[ 0. , 0. ],
[ 1. , 0. ],
[ 1. , 1. ],
[ 0. , 1. ],
[ 0.5, 0.5],
[ 0. , 0.5],
[ 1. , 0.5],
[ 0.5, 0. ],
[ 0.5, 1. ]])
>>> n4eNew
array([[1, 4, 7],
[4, 3, 5],
[5, 7, 4],
[7, 5, 0],
[3, 4, 8],
[4, 1, 6],
[6, 8, 4],
[8, 6, 2]])
>>> n4DbNew
array([[0, 7],
[7, 1],
[1, 6],
[6, 2]])
>>>n4NbNew
array([[2, 8],
[8, 3],
[3, 5],
[5, 0]])
"""
nrNodes = c4n.shape[0]
nrElems = n4e.shape[0]
n4s = compute_n4s(n4e)
nrSides = n4s.shape[0]
from scipy.sparse import coo_matrix
newNodes4s = coo_matrix((np.arange(0,nrSides)+nrNodes, (n4s[:,0], n4s[:,1])), shape=(nrNodes, nrNodes))
newNodes4s = newNodes4s.tocsr()
newNodes4s = newNodes4s + newNodes4s.transpose()
mid4s = (c4n[n4s[:,0],:] + c4n[n4s[:,1],:]) * 0.5
c4nNew = np.vstack((c4n, mid4s))
n4eNew = np.zeros((4 * nrElems, 3), dtype=int)
for elem in range(0,nrElems):
nodes = n4e[elem,:]
newNodes = np.array([newNodes4s[nodes[0],nodes[1]], newNodes4s[nodes[1],nodes[2]], newNodes4s[nodes[2],nodes[0]]])
n4eNew[4*elem + np.arange(0,4),:] = np.array([[nodes[0], newNodes[0], newNodes[2]],
[newNodes[0], nodes[1], newNodes[1]], [newNodes[1], newNodes[2], newNodes[0]],
[newNodes[2], newNodes[1], nodes[2]]])
n4DbNew = np.zeros((2 * n4Db.shape[0], 2), dtype = int)
for side in range(0, n4Db.shape[0]):
nodes = n4Db[side,:]
newNodes = newNodes4s[nodes[0], nodes[1]]
n4DbNew[2*side + np.arange(0,2),:] = np.array([[nodes[0], newNodes], [newNodes, nodes[1]]])
n4NbNew = np.zeros((2 * n4Nb.shape[0], 2), dtype = int)
for side in range(0, n4Nb.shape[0]):
nodes = n4Nb[side,:]
newNodes = newNodes4s[nodes[0], nodes[1]]
n4NbNew[2*side + np.arange(0,2),:] = np.array([[nodes[0], newNodes], [newNodes, nodes[1]]])
return (c4nNew, n4eNew, n4DbNew, n4NbNew) | mit | -4,737,356,614,649,700,000 | 28.58011 | 116 | 0.57706 | false |
googlei18n/glyphsLib | Lib/glyphsLib/builder/masters.py | 1 | 4706 | # Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function, division, absolute_import, unicode_literals
import os
from .axes import font_uses_new_axes, get_axis_definitions
from .constants import GLYPHS_PREFIX, GLYPHLIB_PREFIX
MASTER_ID_LIB_KEY = GLYPHS_PREFIX + "fontMasterID"
UFO_FILENAME_KEY = GLYPHLIB_PREFIX + "ufoFilename"
UFO_YEAR_KEY = GLYPHLIB_PREFIX + "ufoYear"
UFO_NOTE_KEY = GLYPHLIB_PREFIX + "ufoNote"
def to_ufo_master_attributes(self, source, master):
ufo = source.font
ufo.info.ascender = master.ascender
ufo.info.capHeight = master.capHeight
ufo.info.descender = master.descender
ufo.info.xHeight = master.xHeight
horizontal_stems = master.horizontalStems
vertical_stems = master.verticalStems
italic_angle = -master.italicAngle
if horizontal_stems:
ufo.info.postscriptStemSnapH = horizontal_stems
if vertical_stems:
ufo.info.postscriptStemSnapV = vertical_stems
if italic_angle is not None:
ufo.info.italicAngle = italic_angle
year = master.userData[UFO_YEAR_KEY]
if year is not None:
ufo.info.year = year
note = master.userData[UFO_NOTE_KEY]
if note is not None:
ufo.info.note = note
# All of this will go into the designspace as well
# "Native" designspace fonts will only have the designspace info
# FIXME: (jany) maybe we should not duplicate the information and only
# write it in the designspace?
widthValue = master.widthValue
weightValue = master.weightValue
if weightValue is not None:
ufo.lib[GLYPHS_PREFIX + "weightValue"] = weightValue
if widthValue:
ufo.lib[GLYPHS_PREFIX + "widthValue"] = widthValue
for number in ("", "1", "2", "3"):
custom_value = getattr(master, "customValue" + number)
if custom_value:
ufo.lib[GLYPHS_PREFIX + "customValue" + number] = custom_value
if font_uses_new_axes(self.font):
# Set the OS/2 weightClass and widthClas according the this master's
# user location ("Axis Location" parameter)
for axis in get_axis_definitions(self.font):
if axis.tag in ("wght", "wdth"):
user_loc = axis.get_user_loc(master)
axis.set_ufo_user_loc(ufo, user_loc)
self.to_ufo_blue_values(ufo, master)
self.to_ufo_guidelines(ufo, master)
self.to_ufo_master_user_data(ufo, master)
self.to_ufo_custom_params(ufo, master)
master_id = master.id
if self.minimize_glyphs_diffs:
ufo.lib[MASTER_ID_LIB_KEY] = master_id
def to_glyphs_master_attributes(self, source, master):
ufo = source.font
# Glyphs ensures that the master ID is unique by simply making up a new one when
# finding a duplicate.
ufo_master_id_lib_key = ufo.lib.get(MASTER_ID_LIB_KEY)
if ufo_master_id_lib_key and not self.font.masters[ufo_master_id_lib_key]:
master.id = ufo_master_id_lib_key
if source.filename is not None and self.minimize_ufo_diffs:
master.userData[UFO_FILENAME_KEY] = source.filename
elif ufo.path and self.minimize_ufo_diffs:
master.userData[UFO_FILENAME_KEY] = os.path.basename(ufo.path)
master.ascender = ufo.info.ascender
master.capHeight = ufo.info.capHeight
master.descender = ufo.info.descender
master.xHeight = ufo.info.xHeight
horizontal_stems = ufo.info.postscriptStemSnapH
vertical_stems = ufo.info.postscriptStemSnapV
italic_angle = 0
if ufo.info.italicAngle:
italic_angle = -ufo.info.italicAngle
if horizontal_stems:
master.horizontalStems = horizontal_stems
if vertical_stems:
master.verticalStems = vertical_stems
if italic_angle:
master.italicAngle = italic_angle
if ufo.info.year is not None:
master.userData[UFO_YEAR_KEY] = ufo.info.year
if ufo.info.note is not None:
master.userData[UFO_NOTE_KEY] = ufo.info.note
self.to_glyphs_blue_values(ufo, master)
self.to_glyphs_master_names(ufo, master)
self.to_glyphs_master_user_data(ufo, master)
self.to_glyphs_guidelines(ufo, master)
self.to_glyphs_custom_params(ufo, master)
| apache-2.0 | 2,800,870,986,591,150,000 | 36.648 | 84 | 0.694858 | false |
nschloe/quadpy | src/quadpy/tn/_stroud_1969.py | 1 | 1840 | import ndim
import numpy as np
from sympy import Rational as frac
from sympy import sqrt
from ..helpers import article, rd, untangle
from ._helpers import TnScheme
source = article(
authors=["A.H. Stroud"],
title="A Fifth Degree Integration Formula for the n-Simplex",
journal="SIAM J. Numer. Anal.",
volume="6",
number="1",
pages="90–98",
url="https://doi.org/10.1137/0706009",
)
def stroud_1969(n):
assert n >= 3
degree = 5
sqrt15 = sqrt(15)
t = frac(1, n + 1)
r1, r2 = [(n + 4 - pm * sqrt15) / (n ** 2 + 8 * n + 1) for pm in [+1, -1]]
s1, s2 = [(4 * n + 1 + pm * n * sqrt15) / (n ** 2 + 8 * n + 1) for pm in [+1, -1]]
u1, u2 = [(n + 7 + pm * 2 * sqrt15) / (n ** 2 + 14 * n - 11) for pm in [+1, -1]]
v1, v2 = [
(4 * n - 2 - pm * (n - 1) * sqrt15) / (n ** 2 + 14 * n - 11) for pm in [+1, -1]
]
# Solve linear equation system for x^k, k={0, 2, 3, 4, 5}, for the
# weights (the same is done in Stroud's article).
pts = [
np.full((1, n + 1), t),
rd(n + 1, [(r1, n), (s1, 1)]),
rd(n + 1, [(r2, n), (s2, 1)]),
rd(n + 1, [(u1, n - 1), (v1, 2)]),
]
k_range = [0, 2, 3, 4]
if n > 3:
pts.append(rd(n + 1, [(u2, n - 1), (v2, 2)]))
k_range.append(5)
b0 = ndim.nsimplex.integrate_monomial(n * [0], symbolic=True)
b = [
ndim.nsimplex.integrate_monomial(np.array([k] + (n - 1) * [0]), symbolic=True)
/ b0
for k in k_range
]
A = [[sum(p[:, 0] ** k) for p in pts] for k in k_range]
flt = np.vectorize(float)
w = np.linalg.solve(flt(A), flt(b))
data = [(w[i], pts[i]) for i in range(len(w))]
points, weights = untangle(data)
points = np.ascontiguousarray(points.T)
return TnScheme("Stroud 1969", n, weights, points, degree, source)
| mit | 6,444,330,403,827,270,000 | 27.276923 | 87 | 0.507617 | false |
juliakreutzer/wtfrnn | transformTrees.py | 1 | 2645 | import codecs
import sys
from fromTextToFullTree import *
#transform parsed trees into full binary trees
if __name__=="__main__":
limit=15
dataDir = "trees"
trainFile = codecs.open(dataDir+"/train.txt", "r", "utf8")
testFile = codecs.open(dataDir+"/test.txt", "r", "utf8")
devFile = codecs.open(dataDir+"/dev.txt", "r", "utf8")
trainOutFile = codecs.open(dataDir+"/train.full.%d.txt" % limit, "w", "utf8")
testOutFile = codecs.open(dataDir+"/test.full.%d.txt" % limit, "w", "utf8")
devOutFile = codecs.open(dataDir+"/dev.full.%d.txt" % limit, "w", "utf8")
inFiles = [trainFile, testFile, devFile]
outFiles = [trainOutFile, testOutFile, devOutFile]
for f, inFile in enumerate(inFiles):
for i,line in enumerate(inFile):
print "line", i
#first filter words from trees
if not line.startswith("("):
print("Not a valid format.")
sys.exit(-1)
wordLabels = list()
words = list()
sentenceLabel = -1
sentenceLevel = True
lastLabel = -1
word = ""
for j in xrange(len(line)):
char = line[j]
#print "char", char
if char == "(":
continue
elif char == ")":
if len(word)>0:
words.append(word)
#print "new word", word, lastLabel
wordLabels.append(lastLabel)
word = ""
elif char.isspace():
continue
else:
if char.isdigit(): #label
if sentenceLevel:
sentenceLabel = char
#print "sent label", sentenceLabel
sentenceLevel = False
else:
lastLabel = char #save for later
else: #word
word += char
assert len(words) == len(wordLabels)
if len(words)<limit:
#now transform to full tree
#remove phrase-level annotations, keep word-level and sentence-level
treeString = buildTree(words, wordLabels, sentenceLabel)
outFiles[f].write(treeString+"\n")
outFiles[f].flush()
#print sentenceLabel
#print wordLabels
trainFile.close()
testFile.close()
devFile.close()
trainOutFile.close()
testOutFile.close()
devOutFile.close()
| mit | -6,286,931,452,027,079,000 | 31.654321 | 84 | 0.487335 | false |
kamidox/weixin_producthunt | manage.py | 1 | 2537 | """
productporter.manage
~~~~~~~~~~~~~~~~~~~~
This script provides some easy to use commands for
creating the database with or without some sample content.
You can also run the development server with it.
Just type `python manage.py` to see the full list of commands.
:copyright: (c) 2014 by the ProductPorter Team.
:license: BSD, see LICENSE for more details.
"""
import os
import json
from flask import current_app
from flask.ext.script import (Manager, Shell, Server)
from flask.ext.migrate import MigrateCommand
from productporter.app import create_app
from productporter.product.models import Product
from productporter.extensions import db
from productporter.utils.helper import pull_and_save_posts, create_default_groups, \
create_admin_user, create_default_tags
from tests.fixtures.sampledata import SAMPLE_DATA
# Use the development configuration if available
try:
from productporter.configs.production import ProductionConfig as Config
except ImportError:
from productporter.configs.development import DevelopmentConfig as Config
except ImportError:
from productporter.configs.default import DefaultConfig as Config
app = create_app(Config)
manager = Manager(app)
# Run local server
manager.add_command("runserver", Server("localhost", port=5000))
# Migration commands
manager.add_command('db', MigrateCommand)
# Add interactive project shell
def make_shell_context():
return dict(app=current_app, db=db)
manager.add_command("shell", Shell(make_context=make_shell_context))
@manager.command
def initdb():
"""Creates the database."""
db.create_all()
@manager.command
def dropdb():
"""Deletes the database"""
db.drop_all()
@manager.command
def createall():
"""Creates the database."""
print("create database in %s" % (Config.SQLALCHEMY_DATABASE_URI))
db.drop_all()
db.create_all()
create_default_groups()
create_default_tags()
create_admin_user('admin', 'admin', '[email protected]')
@manager.command
def createdefault():
print("create default data for %s" % (Config.SQLALCHEMY_DATABASE_URI))
create_default_groups()
create_default_tags()
create_admin_user('admin', 'admin', '[email protected]')
@manager.command
def pullsample():
"""pull sample data"""
jsondata = json.loads(SAMPLE_DATA)
some_posts = jsondata['posts']
for p in some_posts:
pi = Product.from_json(p)
pi.save()
print('pull %d posts' % (len(some_posts)))
if __name__ == "__main__":
manager.run()
| bsd-2-clause | -6,277,587,297,717,733,000 | 27.829545 | 84 | 0.715018 | false |
tchaly-bethmaure/Emotes | models/emotesV8-1/config_related_save/csv_to_png/csv_to_png.py | 1 | 3825 |
import png
import os
def string_rgbhex_to_lst_rgbdec(strRGBHEX):
# strRGB ex : FFFFFF
if len(strRGBHEX) == 6:
return [give_dec_code(strRGBHEX[0] + strRGBHEX[1]),
give_dec_code(strRGBHEX[2] + strRGBHEX[3]),
give_dec_code(strRGBHEX[4] + strRGBHEX[5])]
else:
return [0, 0, 0]
def give_dec_code(str_as_hex):
#str_as_hex ex: FF or 00
if str_as_hex == "FF":
return 255
if str_as_hex == "00":
return 0
def give_grey_code(str_as_hex):
# str_as_hex ex: FF or 00
if str_as_hex == "FF0000":
return "0"
if str_as_hex == "00FF00":
return "1"
def convert_grey_with_only_RG():
# Conversion Hex to Dec in grey depth 2
zoom = 8;
dir = "/home/tchaly/EspaceDeTravail/Gama/works/EMOTES/models/emotesV8/config_related_save"
for file in os.listdir(dir):
if file.endswith(".csv"):
with open(dir+"/"+file,'r') as fichier:
print("Parsing : "+file+" ...")
line = ""
pixel_col = []
# Read each line of the file
for ligne in fichier.readlines():
pixel_line = ""
# line of pixels separated by a ';' ex : FF00FF;FFFFFF;FF0000; ... etc
line = ligne.strip("\t\r\n")
pixelHEX_tab = line.split(";")
# A pixel is symbolized with a FFFFF hex chars
for pixelHex in pixelHEX_tab:
if pixelHex != "":
for i in range(zoom):
pixel_line += str(give_grey_code(pixelHex))
for i in range(zoom):
pixel_col.append(pixel_line)
print("OK.")
s = map(lambda x: map(int, x), pixel_col)
# Creating Png file
filename = file.replace(".csv",".png")
fichier.close()
print("Writing : "+filename+" ...")
f = open("png/"+filename, 'wb')
w = png.Writer(len(s[0]), len(s), greyscale=True, bitdepth=2)
w.write(f, s)
f.close()
print("OK.")
print("Done.")
def convert_to_RGB():
# Conversion Hex to Dec in grey depth 2
zoom = 8;
dir = "/home/tchaly/EspaceDeTravail/Gama/works/EMOTES/models/emotesV8/config_related_save"
for file in os.listdir(dir):
if file.endswith(".csv"):
with open(dir+"/"+file,'r') as fichier:
print("Parsing : "+file+" ...")
line = ""
pixel_col = []
# Read each line of the file
for ligne in fichier.readlines():
pixel_line = []
# line of pixels separated by a ';' ex : FF00FF;FFFFFF;FF0000; ... etc
line = ligne.strip("\t\r\n")
pixelHEX_tab = line.split(";")
# A pixel is symbolized with a FFFFF hex chars
for pixelHex in pixelHEX_tab:
if pixelHex != "":
for i in range(zoom):
pixel_line.extend(string_rgbhex_to_lst_rgbdec(pixelHex))
for i in range(zoom):
pixel_col.append(pixel_line)
print("OK.")
# Creating Png file
filename = file.replace(".csv",".png")
fichier.close()
print("Writing : "+filename+" ...")
f = open(dir+"/png/"+filename, 'wb')
w = png.Writer(len(pixel_col), len(pixel_col))
w.write(f, pixel_col)
f.close()
print("OK.")
print("Done.")
convert_to_RGB() | gpl-2.0 | -876,502,132,345,458,700 | 35.788462 | 94 | 0.463791 | false |
vivsh/django-ginger | ginger/views/mixins.py | 1 | 1640 |
from ginger.exceptions import LoginRequired, PermissionRequired
from django.core.exceptions import PermissionDenied
__all__ = ['PermissionRequiredMixin', 'PrivilegeRequiredMixin', 'LoginRequiredMixin',
'StaffRequiredMixin', 'SuperUserRequiredMixin', 'OwnerRequiredMixin']
class PermissionRequiredMixin(object):
def get_permission_url(cls, user):
raise NotImplementedError
def get_user(self):
user = super(PermissionRequiredMixin, self).get_user()
url = self.get_permission_url()
if url is not None:
raise PermissionRequired(url)
return user
class LoginRequiredMixin(object):
def get_user(self):
user = super(LoginRequiredMixin, self).get_user()
if not user.is_authenticated():
raise LoginRequired
return user
class OwnerRequiredMixin(LoginRequiredMixin):
def get_target(self):
obj = super(OwnerRequiredMixin, self).get_target()
if not self.user.is_superuser and obj.owner != self.user:
raise PermissionDenied
return obj
class PrivilegeRequiredMixin(LoginRequiredMixin):
def get_user(self):
user = super(PrivilegeRequiredMixin, self).get_user()
if not self.has_privileges(user):
raise PermissionDenied
return user
def has_privileges(self, user):
raise NotImplementedError
class StaffRequiredMixin(PrivilegeRequiredMixin):
def has_privileges(self, user):
return user.is_staff
class SuperUserRequiredMixin(PrivilegeRequiredMixin):
def has_privileges(self, user):
return user.is_superuser
| mit | 8,859,729,103,791,103,000 | 25.031746 | 85 | 0.688415 | false |