max_stars_repo_path
stringlengths 4
245
| max_stars_repo_name
stringlengths 7
115
| max_stars_count
int64 101
368k
| id
stringlengths 2
8
| content
stringlengths 6
1.03M
|
|---|---|---|---|---|
src/Products/Five/sizeconfigure.py | rbanffy/Zope | 289 | 11099317 | ##############################################################################
#
# Copyright (c) 2004, 2005 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Use structured monkey-patching to enable ``ISized`` adapters for
Zope 2 objects.
"""
from Products.Five import fivemethod
from Products.Five import isFiveMethod
from zope.size.interfaces import ISized
from zope.testing.cleanup import addCleanUp # NOQA
# holds classes that were monkeyed with; for clean up
_monkied = []
@fivemethod
def get_size(self):
size = ISized(self, None)
if size is not None:
unit, amount = size.sizeForSorting()
if unit == 'byte':
return amount
method = getattr(self, '__five_original_get_size', None)
if method is not None:
return self.__five_original_get_size()
def classSizable(class_):
"""Monkey the class to be sizable through Five"""
# tuck away the original method if necessary
if hasattr(class_, "get_size") and not isFiveMethod(class_.get_size):
class_.__five_original_get_size = class_.get_size
class_.get_size = get_size
# remember class for clean up
_monkied.append(class_)
def sizable(_context, class_):
_context.action(
discriminator=('five:sizable', class_),
callable=classSizable,
args=(class_,)
)
def killMonkey(class_, name, fallback, attr=None):
"""Die monkey, die!"""
method = getattr(class_, name, None)
if isFiveMethod(method):
original = getattr(class_, fallback, None)
if original is not None:
delattr(class_, fallback)
if original is None or isFiveMethod(original):
try:
delattr(class_, name)
except AttributeError:
pass
else:
setattr(class_, name, original)
if attr is not None:
try:
delattr(class_, attr)
except (AttributeError, KeyError):
pass
def unsizable(class_):
"""Restore class's initial state with respect to being sizable"""
killMonkey(class_, 'get_size', '__five_original_get_size')
def cleanUp():
for class_ in _monkied:
unsizable(class_)
addCleanUp(cleanUp)
del addCleanUp
|
webapp/tests/test_browser.py | romanek-adam/graphite-web | 4,281 | 11099332 | <gh_stars>1000+
# -*- coding: utf-8 -*-
import os
from django.contrib.auth.models import User
try:
from django.urls import reverse
except ImportError: # Django < 1.10
from django.core.urlresolvers import reverse
from .base import TestCase
from django.test.utils import override_settings
from graphite.util import json
from . import DATA_DIR
class BrowserTest(TestCase):
def test_browser(self):
url = reverse('browser')
response = self.client.get(url)
self.assertContains(response, 'Graphite Browser')
def test_header(self):
self.assertEqual(User.objects.count(), 0)
url = reverse('browser_header')
response = self.client.get(url)
self.assertContains(response, 'Graphite Browser Header')
# Graphite has created a default user
self.assertEqual(User.objects.get().username, 'default')
def test_url_prefix(self):
self.assertEqual(reverse('browser'), '/graphite/')
@override_settings(INDEX_FILE=os.path.join(DATA_DIR, 'index'))
def test_search(self):
url = reverse('browser_search')
response = self.client.post(url)
self.assertEqual(response.content, b'')
# simple query
response = self.client.post(url, {'query': 'collectd'})
self.assertEqual(response.content.split(b',')[0],
b'collectd.test.df-root.df_complex-free')
# No match
response = self.client.post(url, {'query': 'other'})
self.assertEqual(response.content, b'')
# Multiple terms (OR)
response = self.client.post(url, {'query': 'midterm shortterm'})
self.assertEqual(response.content.split(b','),
[b'collectd.test.load.load.midterm',
b'collectd.test.load.load.shortterm'])
def test_unicode_graph_name(self):
url = reverse('browser_my_graph')
user = User.objects.create_user('test', '<EMAIL>', '<PASSWORD>')
self.client.login(username='test', password='<PASSWORD>')
response = self.client.get(url, {'path': ''})
self.assertEqual(response.status_code, 200)
user.profile.mygraph_set.create(name=u'fòo', url='bar')
response = self.client.get(url, {'path': ''})
self.assertEqual(response.status_code, 200)
[leaf] = json.loads(response.content)
self.assertEqual(leaf['text'], u'fòo')
def test_unicode_usergraph(self):
url = reverse('browser_usergraph')
user = User.objects.create_user('tèst', '<EMAIL>', '<PASSWORD>')
self.client.login(username='tèst', password='<PASSWORD>')
self.client.get(reverse('browser_header')) # this creates a profile for the user
user.profile.mygraph_set.create(name=u'fòo', url='bar')
response = self.client.get(url, {'query': 'tèst.*',
'format': 'treejson',
'path': 'tèst',
'user': 'tèst',
'node': 'tèst'})
self.assertEqual(response.status_code, 200)
[leaf] = json.loads(response.content)
self.assertEqual(leaf, {
u'leaf': 1,
u'text': u'fòo',
u'allowChildren': 0,
u'graphUrl': u'bar',
u'id': u'tèst.845aa5781192007e1866648eea9f7355',
u'expandable': 0,
})
|
recipes/Python/141602_Barebones_VC_code_invoking_PythCOM_factory/recipe-141602.py | tdiprima/code | 2,023 | 11099356 | <gh_stars>1000+
# Python code
from win32com . server . register import UseCommandLine
from win32api import MessageBox
from win32com . client import Dispatch
from win32ui import MessageBox
class StemmerFactory :
_reg_clsid_ = "{602D10EB-426C-4D6F-A4DF-C05572EB780B}"
_reg_desc_ = "LangTech Stemmer"
_reg_progid_ = "LangTech.Stemmer"
_public_methods_ = [ 'new' ]
def new ( self, scriptFile ) :
self . scriptFile = scriptFile
stemmer = Dispatch ( "LangTech.Stemmer.Product" )
return stemmer
class Stemmer :
_reg_clsid_ = "{B306454A-CAE6-4A74-ACAD-0BB11EF256DD}"
_reg_desc_ = "LangTech Stemmer Product"
_reg_progid_ = "LangTech.Stemmer.Product"
_public_methods_ = [ 'stemWord' ]
def stemWord ( self, word ) :
# extremely simple stemming: if the word ends in 's' then drop the 's'
if word [ -1 ] == "s":
return word [ : -1 ]
else:
return word
if __name__ == '__main__' :
UseCommandLine ( StemmerFactory )
UseCommandLine ( Stemmer )
#----------------------------------------
#
# C++
#include <comdef.h>
#include <initguid.h>
DEFINE_GUID(CLSID_StemmerFactory,
0x602D10EB, 0x426C, 0x4D6F, 0xA4, 0xDF, 0xC0, 0x55, 0x72, 0xEB, 0x78, 0x0B);
DISPID rgDispId ;
OLECHAR * rgszNames [ ] = { OLESTR ( "new" ) };
DISPPARAMS DispParams;
VARIANT VarResult;
EXCEPINFO excepinfo;
UINT uArgErr;
VARIANTARG * pvarg = NULL;
_bstr_t stemmedWord;
HRESULT hr;
IDispatch * stemmerFactory;
IDispatch * stemmer;
if ( FAILED ( hr = CoInitialize ( NULL ) ) ) {
MessageBox ( 0, "CoInitialize failure", "Fault", MB_OK );
break;
}
if ( FAILED ( hr = CoCreateInstance (
CLSID_StemmerFactory,
NULL,
CLSCTX_INPROC_SERVER,
IID_IDispatch,
( LPVOID * ) & stemmerFactory ) ) ) {
MessageBox ( 0, "CoCreateInstance failure", "Fault", MB_OK );
break;
}
if ( FAILED ( hr = stemmerFactory -> GetIDsOfNames (
IID_NULL,
rgszNames,
1,
LOCALE_SYSTEM_DEFAULT,
& rgDispId
) ) ) {
MessageBox ( 0, "GetIDsOfNames failure", "Fault", MB_OK );
break;
}
DispParams.cArgs = 1;
DispParams.cNamedArgs = 0;
DispParams.rgdispidNamedArgs = 0;
pvarg = new VARIANTARG [ DispParams . cArgs ];
if ( pvarg == NULL ) {
MessageBox ( 0, "Insufficient 1st memory", "Fault", MB_OK );
break;
}
pvarg -> vt = VT_BSTR;
pvarg -> bstrVal = SysAllocString ( L"engRules.pl" );
DispParams.rgvarg = pvarg;
if ( FAILED ( hr = stemmerFactory -> Invoke (
rgDispId,
IID_NULL,
LOCALE_SYSTEM_DEFAULT,
DISPATCH_METHOD,
& DispParams,
& VarResult,
& excepinfo,
& uArgErr
) ) ) {
MessageBox ( 0, "1st Invoke failure", "Fault", MB_OK );
break;
}
delete ( pvarg );
stemmer = VarResult.pdispVal;
pvarg = new VARIANTARG [ DispParams . cArgs ];
if ( pvarg == NULL ) {
MessageBox ( 0, "Insufficient 2nd memory", "Fault", MB_OK );
break;
}
pvarg -> vt = VT_BSTR;
pvarg -> bstrVal = SysAllocString ( L"cats" );
DispParams.rgvarg = pvarg;
if ( FAILED ( hr = stemmer -> Invoke (
rgDispId,
IID_NULL,
LOCALE_SYSTEM_DEFAULT,
DISPATCH_METHOD,
& DispParams,
& VarResult,
& excepinfo,
& uArgErr
) ) ) {
MessageBox ( 0, "2nd Invoke failure", "Fault", MB_OK );
break;
}
delete ( pvarg );
stemmedWord = VarResult.bstrVal;
MessageBox (
0,
( const char * ) stemmedWord,
"Resulting Stemmed Word",
MB_OK
);
CoUninitialize ( );
|
tests/ouimeaux_device/api/unit/__init__.py | esev/pywemo | 102 | 11099365 | """Intentionally Empty."""
|
nototools/unittests/layout.py | RoelN/nototools | 156 | 11099386 | # 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.
"""Test general health of the fonts."""
import json
from nototools import render
def _run_harfbuzz(text, font, language, extra_parameters=None):
"""Run harfbuzz on some text and return the shaped list."""
try:
# if extra_parameters is a string, split it into a list
extra_parameters = extra_parameters.split(" ")
except AttributeError:
pass
hb_output = render.run_harfbuzz_on_text(text, font, language, extra_parameters)
return json.loads(hb_output)
_advance_cache = {}
def get_advances(text, font, extra_parameters=None):
"""Get a list of horizontal advances for text rendered in a font."""
try:
return _advance_cache[(text, font, extra_parameters)]
except KeyError:
pass
hb_output = _run_harfbuzz(text, font, None, extra_parameters)
advances = [glyph["ax"] for glyph in hb_output]
_advance_cache[(text, font, extra_parameters)] = advances
return advances
_shape_cache = {}
def get_glyphs(text, font, extra_parameters=None):
"""Get a list of shaped glyphs for text rendered in a font."""
try:
return _shape_cache[(text, font, extra_parameters)]
except KeyError:
pass
hb_output = _run_harfbuzz(text, font, None, extra_parameters)
shapes = [glyph["g"] for glyph in hb_output]
_shape_cache[(text, font, extra_parameters)] = shapes
return shapes
|
tests/test_ecdsa.py | adithyabsk/cryptos | 822 | 11099439 | <gh_stars>100-1000
"""
Test our ability to sign and verify digital signatures
"""
import os
from io import BytesIO
from cryptos.bitcoin import BITCOIN
from cryptos.keys import gen_key_pair
from cryptos.ecdsa import Signature, sign, verify
from cryptos.transaction import Tx
def test_ecdsa():
# let's create two identities
sk1, pk1 = gen_key_pair()
sk2, pk2 = gen_key_pair() # pylint: disable=unused-variable
message = ('user pk1 would like to pay user pk2 1 BTC kkthx').encode('ascii')
# an evil user2 attempts to submit the transaction to the network with some totally random signature
sig = Signature(int.from_bytes(os.urandom(32), 'big'), int.from_bytes(os.urandom(32), 'big'))
# a few seconds later a hero miner inspects the candidate transaction
is_legit = verify(pk1, message, sig)
assert not is_legit
# unlike user2, hero miner is honest and discards the transaction, all is well
# evil user2 does not give up and tries to sign with his key pair
sig = sign(sk2, message)
is_legit = verify(pk1, message, sig)
assert not is_legit
# denied, again!
# lucky for user2, user1 feels sorry for them and the hardships they have been through recently
sig = sign(sk1, message)
is_legit = verify(pk1, message, sig)
assert is_legit
# hero miner validates the transaction and adds it to their block
# user2 happy, buys a Tesla, and promises to turn things around
# the end.
def test_sig_der():
# a transaction used as an example in programming bitcoin
raw = bytes.fromhex('0100000001813f79011acb80925dfe69b3def355fe914bd1d96a3f5f71bf8303c6a989c7d1000000006b483045022100ed81ff192e75a3fd2304004dcadb746fa5e24c5031ccfcf21320b0277457c98f02207a986d955c6e0cb35d446a89d3f56100f4d7f67801c31967743a9c8e10615bed01210349fc4e631e3624a545de3f89f5d8684c7b8138bd94bdd531d2e213bf016b278afeffffff02a135ef01000000001976a914bc3b654dca7e56b04dca18f2566cdaf02e8d9ada88ac99c39800000000001976a9141c4bc762dd5423e332166702cb75f40df79fea1288ac19430600')
tx = Tx.decode(BytesIO(raw))
der = tx.tx_ins[0].script_sig.cmds[0][:-1] # this is the DER signature of the first input on this tx. :-1 crops out the sighash-type byte
sig = Signature.decode(der) # making sure no asserts get tripped up inside this call
# from programming bitcoin chapter 4
der = bytes.fromhex('3045022037206a0610995c58074999cb9767b87af4c4978db68c06e8e6e81d282047a7c60221008ca63759c1157ebeaec0d03cecca119fc9a75bf8e6d0fa65c841c8e2738cdaec')
sig = Signature.decode(der)
assert sig.r == 0x37206a0610995c58074999cb9767b87af4c4978db68c06e8e6e81d282047a7c6
assert sig.s == 0x8ca63759c1157ebeaec0d03cecca119fc9a75bf8e6d0fa65c841c8e2738cdaec
# test that we can also recover back the same der encoding
der2 = sig.encode()
assert der == der2
|
waffle/tests/base.py | theunraveler/django-waffle | 302 | 11099450 | <reponame>theunraveler/django-waffle<filename>waffle/tests/base.py<gh_stars>100-1000
from __future__ import unicode_literals
from django import test
from django.core import cache
class TestCase(test.TransactionTestCase):
def _pre_setup(self):
cache.cache.clear()
super(TestCase, self)._pre_setup()
class ReplicationRouter(object):
"""Router for simulating an environment with DB replication
This router directs all DB reads to a completely different database than
writes. This can be useful for simulating an environment where DB
replication is delayed to identify potential race conditions.
"""
def db_for_read(self, model, **hints):
return 'readonly'
def db_for_write(self, model, **hints):
return 'default'
|
pymtl3/passes/backends/yosys/test/TranslationImport_closed_loop_component_input_test.py | kevinyuan/pymtl3 | 152 | 11099513 | <gh_stars>100-1000
#=========================================================================
# TranslationImport_closed_loop_component_input_test.py
#=========================================================================
# Author : <NAME>
# Date : June 6, 2019
"""Closed-loop test cases for translation-import with component and input."""
from random import seed
from pymtl3.passes.backends.verilog.test.TranslationImport_closed_loop_component_input_test import (
test_adder,
test_mux,
)
from pymtl3.passes.backends.verilog.util.test_utility import (
closed_loop_component_input_test,
)
from pymtl3.passes.rtlir.util.test_utility import do_test
seed( 0xdeadebeef )
def local_do_test( m ):
closed_loop_component_input_test( m, m._tvs, m._tv_in, "yosys" )
|
bindings/pydeck/examples/h3_cluster_layer.py | StijnAmeloot/deck.gl | 7,702 | 11099515 | """
H3ClusterLayer
==============
Data grouped by H3 geohash, as an example of one of the geohash schemes supported by pydeck.
This layer joins contiguous regions into the same color. Data format is as follows:
[
{
"mean": 73.333,
"count": 440,
"hexIds": [
"88283082b9fffff",
"88283082b1fffff",
"88283082b5fffff",
"88283082b7fffff",
"88283082bbfffff",
"882830876dfffff"
]
},
{
"mean": 384.444,
"count": 3460,
"hexIds": [
"8828308281fffff",
"8828308287fffff",
"88283082abfffff",
"88283082a3fffff",
"8828308289fffff",
"88283082c7fffff",
"88283082c3fffff",
"88283082c1fffff",
"88283082d5fffff"
]
},
...
If you'd simply like to plot a value at an H3 hex ID, see the H3HexagonLayer.
This example is adapted from the deck.gl documentation.
"""
import pydeck as pdk
import pandas as pd
H3_CLUSTER_LAYER_DATA = "https://raw.githubusercontent.com/visgl/deck.gl-data/master/website/sf.h3clusters.json" # noqa
df = pd.read_json(H3_CLUSTER_LAYER_DATA)
# Define a layer to display on a map
layer = pdk.Layer(
"H3ClusterLayer",
df,
pickable=True,
stroked=True,
filled=True,
extruded=False,
get_hexagons="hexIds",
get_fill_color="[255, (1 - mean / 500) * 255, 0]",
get_line_color=[255, 255, 255],
line_width_min_pixels=2,
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295, longitude=-122.4194155, zoom=11, bearing=0, pitch=30)
# Render
r = pdk.Deck(layers=[layer], initial_view_state=view_state, tooltip={"text": "Density: {mean}"})
r.to_html("h3_cluster_layer.html")
|
zktraffic/base/network.py | fakeNetflix/twitter-repo-zktraffic | 159 | 11099518 | # ==================================================================================================
# Copyright 2014 Twitter, Inc.
# --------------------------------------------------------------------------------------------------
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this work except in compliance with the License.
# You may obtain a copy of the License in the LICENSE file, or 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.
# ==================================================================================================
""" network packets & header processing stuff """
import socket
import dpkt
from abc import ABCMeta, abstractmethod
import six
from threading import Thread
class Error(Exception): pass
class BadPacket(Error): pass
_loopback = dpkt.loopback.Loopback()
_ethernet = dpkt.ethernet.Ethernet()
def get_ip_packet(data, client_port=0, server_port=0, is_loopback=False):
""" if {client,server}_port is 0 any {client,server}_port is good """
header = _loopback if is_loopback else _ethernet
header.unpack(data)
tcp_p = getattr(header.data, "data", None)
if type(tcp_p) != dpkt.tcp.TCP:
raise BadPacket("Not a TCP packet")
if tcp_p.dport == server_port:
if client_port != 0 and tcp_p.sport != client_port:
raise BadPacket("Request from different client")
elif tcp_p.sport == server_port:
if client_port != 0 and tcp_p.dport != client_port:
raise BadPacket("Reply for different client")
else:
if server_port > 0:
raise BadPacket("Packet not for/from client/server")
return header.data
def get_ip(ip_packet, packed_addr):
af_type = socket.AF_INET if type(ip_packet) == dpkt.ip.IP else socket.AF_INET6
return socket.inet_ntop(af_type, packed_addr)
@six.add_metaclass(ABCMeta)
class SnifferBase(Thread):
def __init__(self):
super(SnifferBase, self).__init__()
@abstractmethod
def handle_packet(self, packet): # pragma: no cover
pass
@abstractmethod
def handle_message(self, message): # pragma: no cover
pass
@abstractmethod
def message_from_packet(self, packet): # pragma: no cover
pass
|
networkx-d3-v2/lib/gdata/exif/__init__.py | suraj-testing2/Clock_Websites | 2,293 | 11099532 | # -*-*- encoding: utf-8 -*-*-
#
# This is gdata.photos.exif, implementing the exif namespace in gdata
#
# $Id: __init__.py 81 2007-10-03 14:41:42Z havard.gulldahl $
#
# Copyright 2007 <NAME>
# Portions copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module maps elements from the {EXIF} namespace[1] to GData objects.
These elements describe image data, using exif attributes[2].
Picasa Web Albums uses the exif namespace to represent Exif data encoded
in a photo [3].
Picasa Web Albums uses the following exif elements:
exif:distance
exif:exposure
exif:flash
exif:focallength
exif:fstop
exif:imageUniqueID
exif:iso
exif:make
exif:model
exif:tags
exif:time
[1]: http://schemas.google.com/photos/exif/2007.
[2]: http://en.wikipedia.org/wiki/Exif
[3]: http://code.google.com/apis/picasaweb/reference.html#exif_reference
"""
__author__ = u'<EMAIL>'# (<NAME>)' #BUG: pydoc chokes on non-ascii chars in __author__
__license__ = 'Apache License v2'
import atom
import gdata
EXIF_NAMESPACE = 'http://schemas.google.com/photos/exif/2007'
class ExifBaseElement(atom.AtomBase):
"""Base class for elements in the EXIF_NAMESPACE (%s). To add new elements, you only need to add the element tag name to self._tag
""" % EXIF_NAMESPACE
_tag = ''
_namespace = EXIF_NAMESPACE
_children = atom.AtomBase._children.copy()
_attributes = atom.AtomBase._attributes.copy()
def __init__(self, name=None, extension_elements=None,
extension_attributes=None, text=None):
self.name = name
self.text = text
self.extension_elements = extension_elements or []
self.extension_attributes = extension_attributes or {}
class Distance(ExifBaseElement):
"(float) The distance to the subject, e.g. 0.0"
_tag = 'distance'
def DistanceFromString(xml_string):
return atom.CreateClassFromXMLString(Distance, xml_string)
class Exposure(ExifBaseElement):
"(float) The exposure time used, e.g. 0.025 or 8.0E4"
_tag = 'exposure'
def ExposureFromString(xml_string):
return atom.CreateClassFromXMLString(Exposure, xml_string)
class Flash(ExifBaseElement):
"""(string) Boolean value indicating whether the flash was used.
The .text attribute will either be `true' or `false'
As a convenience, this object's .bool method will return what you want,
so you can say:
flash_used = bool(Flash)
"""
_tag = 'flash'
def __bool__(self):
if self.text.lower() in ('true','false'):
return self.text.lower() == 'true'
def FlashFromString(xml_string):
return atom.CreateClassFromXMLString(Flash, xml_string)
class Focallength(ExifBaseElement):
"(float) The focal length used, e.g. 23.7"
_tag = 'focallength'
def FocallengthFromString(xml_string):
return atom.CreateClassFromXMLString(Focallength, xml_string)
class Fstop(ExifBaseElement):
"(float) The fstop value used, e.g. 5.0"
_tag = 'fstop'
def FstopFromString(xml_string):
return atom.CreateClassFromXMLString(Fstop, xml_string)
class ImageUniqueID(ExifBaseElement):
"(string) The unique image ID for the photo. Generated by Google Photo servers"
_tag = 'imageUniqueID'
def ImageUniqueIDFromString(xml_string):
return atom.CreateClassFromXMLString(ImageUniqueID, xml_string)
class Iso(ExifBaseElement):
"(int) The iso equivalent value used, e.g. 200"
_tag = 'iso'
def IsoFromString(xml_string):
return atom.CreateClassFromXMLString(Iso, xml_string)
class Make(ExifBaseElement):
"(string) The make of the camera used, e.g. Fictitious Camera Company"
_tag = 'make'
def MakeFromString(xml_string):
return atom.CreateClassFromXMLString(Make, xml_string)
class Model(ExifBaseElement):
"(string) The model of the camera used,e.g AMAZING-100D"
_tag = 'model'
def ModelFromString(xml_string):
return atom.CreateClassFromXMLString(Model, xml_string)
class Time(ExifBaseElement):
"""(int) The date/time the photo was taken, e.g. 1180294337000.
Represented as the number of milliseconds since January 1st, 1970.
The value of this element will always be identical to the value
of the <gphoto:timestamp>.
Look at this object's .isoformat() for a human friendly datetime string:
photo_epoch = Time.text # 1180294337000
photo_isostring = Time.isoformat() # '2007-05-27T19:32:17.000Z'
Alternatively:
photo_datetime = Time.datetime() # (requires python >= 2.3)
"""
_tag = 'time'
def isoformat(self):
"""(string) Return the timestamp as a ISO 8601 formatted string,
e.g. '2007-05-27T19:32:17.000Z'
"""
import time
epoch = float(self.text)/1000
return time.strftime('%Y-%m-%dT%H:%M:%S.000Z', time.gmtime(epoch))
def datetime(self):
"""(datetime.datetime) Return the timestamp as a datetime.datetime object
Requires python 2.3
"""
import datetime
epoch = float(self.text)/1000
return datetime.datetime.fromtimestamp(epoch)
def TimeFromString(xml_string):
return atom.CreateClassFromXMLString(Time, xml_string)
class Tags(ExifBaseElement):
"""The container for all exif elements.
The <exif:tags> element can appear as a child of a photo entry.
"""
_tag = 'tags'
_children = atom.AtomBase._children.copy()
_children['{%s}fstop' % EXIF_NAMESPACE] = ('fstop', Fstop)
_children['{%s}make' % EXIF_NAMESPACE] = ('make', Make)
_children['{%s}model' % EXIF_NAMESPACE] = ('model', Model)
_children['{%s}distance' % EXIF_NAMESPACE] = ('distance', Distance)
_children['{%s}exposure' % EXIF_NAMESPACE] = ('exposure', Exposure)
_children['{%s}flash' % EXIF_NAMESPACE] = ('flash', Flash)
_children['{%s}focallength' % EXIF_NAMESPACE] = ('focallength', Focallength)
_children['{%s}iso' % EXIF_NAMESPACE] = ('iso', Iso)
_children['{%s}time' % EXIF_NAMESPACE] = ('time', Time)
_children['{%s}imageUniqueID' % EXIF_NAMESPACE] = ('imageUniqueID', ImageUniqueID)
def __init__(self, extension_elements=None, extension_attributes=None, text=None):
ExifBaseElement.__init__(self, extension_elements=extension_elements,
extension_attributes=extension_attributes,
text=text)
self.fstop=None
self.make=None
self.model=None
self.distance=None
self.exposure=None
self.flash=None
self.focallength=None
self.iso=None
self.time=None
self.imageUniqueID=None
def TagsFromString(xml_string):
return atom.CreateClassFromXMLString(Tags, xml_string)
|
Game28/modules/sprites/__init__.py | ttkaixin1998/pikachupythongames | 4,013 | 11099544 | '''初始化'''
from .hero import Hero
from .button import Button |
backend/apps/mails/admin.py | KuanWeiLee/froggy-service | 174 | 11099555 | from django.contrib import admin
from .models import SendGridMail, SendGridMailTemplate
admin.site.register(SendGridMailTemplate)
admin.site.register(SendGridMail)
|
tests/fixtures/io.py | lizhifeng1998/schnetpack | 450 | 11099564 | import pytest
import torch
import numpy as np
__all__ = [
# input
"schnet_batch",
"max_atoms_in_batch",
"neighbors",
"neighbor_mask",
"positions",
"cell",
"cell_offset",
"r_ij",
"f_ij",
"random_atomic_env",
"random_interatomic_distances",
"random_input_dim",
"random_output_dim",
"random_shape",
"random_float_input",
"random_int_input",
# output
"schnet_output_shape",
"interaction_output_shape",
"cfconv_output_shape",
"gaussian_smearing_shape",
]
# inputs
# from data
@pytest.fixture
def schnet_batch(example_loader):
return next(iter(example_loader))
# components of batch
@pytest.fixture
def max_atoms_in_batch(schnet_batch):
return schnet_batch["_positions"].shape[1]
@pytest.fixture
def neighbors(schnet_batch):
return schnet_batch["_neighbors"]
@pytest.fixture
def neighbor_mask(schnet_batch):
return schnet_batch["_neighbor_mask"]
@pytest.fixture
def positions(schnet_batch):
return schnet_batch["_positions"]
@pytest.fixture
def cell(schnet_batch):
return schnet_batch["_cell"]
@pytest.fixture
def cell_offset(schnet_batch):
return schnet_batch["_cell_offset"]
@pytest.fixture
def r_ij(atom_distances, positions, neighbors, cell, cell_offset, neighbor_mask):
return atom_distances(positions, neighbors, cell, cell_offset, neighbor_mask)
@pytest.fixture
def f_ij(gaussion_smearing_layer, r_ij):
return gaussion_smearing_layer(r_ij)
@pytest.fixture
def random_atomic_env(batch_size, max_atoms_in_batch, n_filters):
return torch.rand((batch_size, max_atoms_in_batch, n_filters))
@pytest.fixture
def random_interatomic_distances(batch_size, max_atoms_in_batch, cutoff):
return (
(1 - torch.rand((batch_size, max_atoms_in_batch, max_atoms_in_batch - 1)))
* 2
* cutoff
)
@pytest.fixture
def random_input_dim(random_shape):
return random_shape[-1]
@pytest.fixture
def random_output_dim():
return np.random.randint(1, 20, 1).item()
@pytest.fixture
def random_shape():
return list(np.random.randint(1, 8, 3))
@pytest.fixture
def random_float_input(random_shape):
return torch.rand(random_shape, dtype=torch.float32)
@pytest.fixture
def random_int_input(random_shape):
return torch.randint(0, 20, random_shape)
# outputs
# spk.representation
@pytest.fixture
def schnet_output_shape(batch_size, max_atoms_in_batch, n_atom_basis):
return [batch_size, max_atoms_in_batch, n_atom_basis]
@pytest.fixture
def interaction_output_shape(batch_size, max_atoms_in_batch, n_filters):
return [batch_size, max_atoms_in_batch, n_filters]
@pytest.fixture
def cfconv_output_shape(batch_size, max_atoms_in_batch, n_atom_basis):
return [batch_size, max_atoms_in_batch, n_atom_basis]
# spk.nn
@pytest.fixture
def gaussian_smearing_shape(batch_size, max_atoms_in_batch, n_gaussians):
return [batch_size, max_atoms_in_batch, max_atoms_in_batch - 1, n_gaussians]
|
code/dataset/megadepth_train.py | theNded/SGP | 137 | 11099624 | <reponame>theNded/SGP
import os, sys
file_path = os.path.abspath(__file__)
project_path = os.path.dirname(os.path.dirname(file_path))
sys.path.append(project_path)
import cv2
import numpy as np
import open3d as o3d
from dataset.base import DatasetBase
from geometry.image import compute_fundamental_from_poses, detect_keypoints, extract_feats, match_feats, estimate_essential, draw_matches
class DatasetMegaDepthTrain(DatasetBase):
def __init__(self, root, scenes):
super(DatasetMegaDepthTrain, self).__init__(root, scenes)
# override
def parse_scene(self, root, scene):
scene_path = os.path.join(root, scene)
fnames = os.listdir(os.path.join(scene_path, 'images'))
fnames_map = {fname: i for i, fname in enumerate(fnames)}
# Load pairs.txt
pair_fname = os.path.join(scene_path, 'pairs.txt')
with open(pair_fname, 'r') as f:
pair_content = f.readlines()
pairs = []
for line in pair_content:
lst = line.strip().split(' ')
src_fname = lst[0]
dst_fname = lst[1]
src_idx = fnames_map[src_fname]
dst_idx = fnames_map[dst_fname]
pairs.append((src_idx, dst_idx))
cam_fname = os.path.join(scene_path, 'img_cam.txt')
with open(cam_fname, 'r') as f:
cam_content = f.readlines()
cnt = 0
intrinsics = np.zeros((len(fnames), 3, 3))
extrinsics = np.zeros((len(fnames), 4, 4))
for line in cam_content:
line = line.strip()
if len(line) > 0 and line[0] != "#":
lst = line.split()
fname = lst[0]
idx = fnames_map[fname]
fx, fy = float(lst[3]), float(lst[4])
cx, cy = float(lst[5]), float(lst[6])
R = np.array(lst[7:16]).reshape((3, 3))
t = np.array(lst[16:19])
T = np.eye(4)
T[:3, :3] = R
T[:3, 3] = t
intrinsics[idx] = np.array([fx, 0, cx, 0, fy, cy, 0, 0,
1]).reshape((3, 3))
extrinsics[idx] = T
cnt += 1
assert cnt == len(fnames)
return {
'folder': scene,
'fnames': fnames,
'pairs': pairs,
'unary_info': [(K, T) for K, T in zip(intrinsics, extrinsics)],
'binary_info': [None for i in range(len(pairs))]
}
# override
def load_data(self, folder, fname):
fname = os.path.join(self.root, folder, 'images', fname)
return cv2.imread(fname)
# override
def collect_scenes(self, root, scenes):
scene_collection = []
for scene in scenes:
scene_path = os.path.join(root, scene)
subdirs = os.listdir(scene_path)
for subdir in subdirs:
if subdir.startswith('dense') and \
os.path.isdir(
os.path.join(scene_path, subdir)):
scene_dict = self.parse_scene(
root, os.path.join(scene, subdir, 'aligned'))
scene_collection.append(scene_dict)
return scene_collection
|
cloths_segmentation/metrics.py | fighting332/cloths_segmentation | 134 | 11099627 | import torch
EPSILON = 1e-15
def binary_mean_iou(logits: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
output = (logits > 0).int()
if output.shape != targets.shape:
targets = torch.squeeze(targets, 1)
intersection = (targets * output).sum()
union = targets.sum() + output.sum() - intersection
result = (intersection + EPSILON) / (union + EPSILON)
return result
|
aleph/migrate/versions/40d6ffcd8442_add_mappings_table.py | Rosencrantz/aleph | 1,213 | 11099642 | """Introduce table to store mappings in the DB.
Revision ID: 40d6ffcd8442
Revises: <PASSWORD>
Create Date: 2019-10-02 04:37:55.784441
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "8a8ef1f7e6fa"
def upgrade():
op.create_table(
"mapping",
sa.Column("created_at", sa.DateTime(), nullable=True),
sa.Column("updated_at", sa.DateTime(), nullable=True),
sa.Column("deleted_at", sa.DateTime(), nullable=True),
sa.Column("id", sa.Integer(), nullable=False),
sa.Column("query", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
sa.Column("role_id", sa.Integer(), nullable=True),
sa.Column("collection_id", sa.Integer(), nullable=True),
sa.Column("table_id", sa.String(length=128), nullable=True),
sa.ForeignKeyConstraint(["collection_id"], ["collection.id"],),
sa.ForeignKeyConstraint(["role_id"], ["role.id"],),
sa.PrimaryKeyConstraint("id"),
)
op.create_index(
op.f("ix_mapping_collection_id"), "mapping", ["collection_id"], unique=False
)
op.create_index(op.f("ix_mapping_role_id"), "mapping", ["role_id"], unique=False)
op.create_index(op.f("ix_mapping_table_id"), "mapping", ["table_id"], unique=False)
def downgrade():
pass
|
tools/utilities/pythonlibs/audio/compute_ell_model.py | shawncal/ELL | 2,094 | 11099664 | ###################################################################################################
#
# Project: Embedded Learning Library (ELL)
# File: compute_ell_model.py
# Authors: <NAME>
#
# Requires: Python 3.x
#
###################################################################################################
import os
import sys
import numpy as np
try:
# try and import ELL from site_packages
import ell
except:
# try and use ELL_ROOT environment variable to find ELL.
ell_root = os.getenv("ELL_ROOT")
if not ell_root:
raise Exception("Please set your ELL_ROOT environment variable")
sys.path += [os.path.join(ell_root, "build", "interfaces", "python", "package")]
import ell
class ComputeModel:
""" This class wraps a .ell model, exposing the model compute function as a
transform method """
def __init__(self, model_path):
self.model_path = model_path
self.map = ell.model.Map(model_path)
self.input_shape = self.map.GetInputShape()
self.output_shape = self.map.GetOutputShape()
self.state_size = 0
if self.map.NumInputs() == 2 and self.map.NumOutputs() == 2:
# then perhaps we have a FastGRNN model with external state.
self.input_size = self.input_shape.Size()
self.output_size = self.output_shape.Size()
self.state_size = self.map.GetInputShape(1).Size()
self.output_buffer = ell.math.FloatVector(self.output_size)
self.hidden_state = ell.math.FloatVector(self.state_size)
self.new_state = ell.math.FloatVector(self.state_size)
def predict(self, x):
return self.transform(x)
def transform(self, x):
""" call the ell model with input array 'x' and return the output as numpy array """
# Send the input to the predict function and return the prediction result
if self.state_size:
i = ell.math.FloatVector(x)
self.map.ComputeMultiple([i, self.hidden_state], [self.output_buffer, self.new_state])
self.hidden_state.copy_from(self.new_state)
out_vec = self.output_buffer
else:
out_vec = self.map.Compute(x)
return np.array(out_vec)
def reset(self):
""" reset all model state """
self.map.Reset()
if self.state_size:
self.hidden_state = ell.math.FloatVector(self.state_size)
def get_metadata(self, name):
model = self.map.GetModel()
value = self.map.GetMetadataValue(name)
if value:
return value
value = model.GetMetadataValue(name)
if value:
return value
nodes = model.GetNodes()
while nodes.IsValid():
node = nodes.Get()
value = node.GetMetadataValue(name)
if value:
return value
nodes.Next()
return None
|
music21/instrument.py | cuthbertLab/music21 | 1,449 | 11099698 | # -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
# Name: instrument.py
# Purpose: Class for basic instrument information
#
# Authors: <NAME>
# <NAME>
# <NAME>
# <NAME>
# <NAME>
# <NAME>
#
# Copyright: Copyright © 2009-2012, 17, 20 <NAME> and the music21 Project
# License: BSD, see license.txt
# ------------------------------------------------------------------------------
'''
This module represents instruments through objects that contain general information
such as Metadata for instrument names, classifications, transpositions and default
MIDI program numbers. It also contains information specific to each instrument
or instrument family, such as string pitches, etc. Information about instrumental
ensembles is also included here though it may later be separated out into its own
ensemble.py module.
'''
import copy
import unittest
import sys
from collections import OrderedDict
from typing import Optional
from music21 import base
from music21 import common
from music21 import interval
from music21 import note
from music21 import pitch
from music21 import stream
from music21.tree.trees import OffsetTree
from music21.exceptions21 import InstrumentException
from music21 import environment
_MOD = 'instrument'
environLocal = environment.Environment(_MOD)
StreamType = stream.StreamType
def unbundleInstruments(streamIn: StreamType, *, inPlace=False) -> Optional[StreamType]:
# noinspection PyShadowingNames
'''
takes a :class:`~music21.stream.Stream` that has :class:`~music21.note.NotRest` objects
and moves their `.storedInstrument` attributes to a new Stream (unless inPlace=True)
>>> up1 = note.Unpitched()
>>> up1.storedInstrument = instrument.BassDrum()
>>> up2 = note.Unpitched()
>>> up2.storedInstrument = instrument.Cowbell()
>>> s = stream.Stream()
>>> s.append(up1)
>>> s.append(up2)
>>> s2 = instrument.unbundleInstruments(s)
>>> s2.show('text')
{0.0} <music21.instrument.BassDrum 'Bass Drum'>
{0.0} <music21.note.Unpitched object at 0x...>
{1.0} <music21.instrument.Cowbell 'Cowbell'>
{1.0} <music21.note.Unpitched object at 0x...>
'''
if inPlace is True:
s = streamIn
else:
s = streamIn.coreCopyAsDerivation('unbundleInstruments')
for thisObj in s:
if isinstance(thisObj, note.NotRest):
# eventually also unbundle each note of chord, but need new voices
i = thisObj.storedInstrument
if i is not None:
off = thisObj.offset
s.insert(off, i)
if inPlace is False:
return s
def bundleInstruments(streamIn: stream.Stream, *, inPlace=False) -> Optional[stream.Stream]:
# noinspection PyShadowingNames
'''
>>> up1 = note.Unpitched()
>>> up1.storedInstrument = instrument.BassDrum()
>>> upUnknownInstrument = note.Unpitched()
>>> up2 = note.Unpitched()
>>> up2.storedInstrument = instrument.Cowbell()
>>> s = stream.Stream()
>>> s.append(up1)
>>> s.append(upUnknownInstrument)
>>> s.append(up2)
>>> s2 = instrument.unbundleInstruments(s)
>>> s3 = instrument.bundleInstruments(s2)
>>> for test in s3:
... print(test.storedInstrument)
Bass Drum
Bass Drum
Cowbell
'''
if inPlace is True:
s = streamIn
else:
s = streamIn.coreCopyAsDerivation('bundleInstruments')
lastInstrument = None
for thisObj in s:
if 'Instrument' in thisObj.classes:
lastInstrument = thisObj
s.remove(thisObj)
elif isinstance(thisObj, note.NotRest):
thisObj.storedInstrument = lastInstrument
if inPlace is False:
return s
class Instrument(base.Music21Object):
'''
Base class for all musical instruments. Designed
for subclassing, though usually a more specific
instrument class (such as StringInstrument) would
be better to subclass.
Some defined attributes for instruments include:
* partId
* partName
* partAbbreviation
* instrumentId
* instrumentName
* instrumentAbbreviation
* midiProgram (0-indexed)
* midiChannel (0-indexed)
* lowestNote (a note object or a string for _written_ pitch)
* highestNote (a note object or a string for _written_ pitch)
* transposition (an interval object)
* inGMPercMap (bool -- if it uses the GM percussion map)
* soundfontFn (filepath to a sound font, optional)
'''
classSortOrder = -25
def __init__(self, instrumentName=None):
super().__init__()
self.partId = None
self._partIdIsRandom = False
self.partName = None
self.partAbbreviation = None
self.printPartName = None # True = yes, False = no, None = let others decide
self.printPartAbbreviation = None
self.instrumentId: Optional[str] = None # apply to midi and instrument
self._instrumentIdIsRandom = False
self.instrumentName = instrumentName
self.instrumentAbbreviation = None
self.midiProgram = None # 0-indexed
self.midiChannel = None # 0-indexed
self.instrumentSound = None
self.lowestNote = None
self.highestNote = None
# define interval to go from written to sounding
self.transposition: Optional[interval.Interval] = None
self.inGMPercMap = False
self.soundfontFn = None # if defined...
def __str__(self):
msg = []
if self.partId is not None:
msg.append(f'{self.partId}: ')
if self.partName is not None:
msg.append(f'{self.partName}: ')
if self.instrumentName is not None:
msg.append(self.instrumentName)
return ''.join(msg)
def _reprInternal(self):
return repr(str(self))
def __deepcopy__(self, memo=None):
new = common.defaultDeepcopy(self, memo)
if self._partIdIsRandom:
new.partIdRandomize()
if self._instrumentIdIsRandom:
new.instrumentIdRandomize()
return new
def bestName(self):
'''
Find a viable name, looking first at instrument, then part, then
abbreviations.
'''
if self.partName is not None:
return self.partName
elif self.partAbbreviation is not None:
return self.partAbbreviation
elif self.instrumentName is not None:
return self.instrumentName
elif self.instrumentAbbreviation is not None:
return self.instrumentAbbreviation
else:
return None
def partIdRandomize(self):
'''
Force a unique id by using an MD5
'''
idNew = f'P{common.getMd5()}'
# environLocal.printDebug(['incrementing instrument from',
# self.partId, 'to', idNew])
self.partId = idNew
self._partIdIsRandom = True
def instrumentIdRandomize(self):
'''
Force a unique id by using an MD5
'''
idNew = f'I{common.getMd5()}'
# environLocal.printDebug(['incrementing instrument from',
# self.partId, 'to', idNew])
self.instrumentId = idNew
self._instrumentIdIsRandom = True
# the empty list as default is actually CORRECT!
# noinspection PyDefaultArgument
def autoAssignMidiChannel(self, usedChannels=[]): # pylint: disable=dangerous-default-value
'''
Assign an unused midi channel given a list of
used channels.
assigns the number to self.midiChannel and returns
it as an int.
Note that midi channel 10 (9 in music21) is special, and
thus is skipped.
Currently only 16 channels are used.
Note that the reused "usedChannels=[]" in the
signature is NOT a mistake, but necessary for
the case where there needs to be a global list.
>>> used = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11]
>>> i = instrument.Violin()
>>> i.autoAssignMidiChannel(used)
12
>>> i.midiChannel
12
Unpitched percussion will be set to 9, so long as it's not in the filter list:
>>> used = [0]
>>> i = instrument.Maracas()
>>> i.autoAssignMidiChannel(used)
9
>>> i.midiChannel
9
>>> used = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> i = instrument.Woodblock()
>>> i.autoAssignMidiChannel(used)
11
>>> i.midiChannel
11
OMIT_FROM_DOCS
>>> used2 = range(16)
>>> i = instrument.Instrument()
>>> i.autoAssignMidiChannel(used2)
Traceback (most recent call last):
music21.exceptions21.InstrumentException: we are out of midi channels! help!
'''
# NOTE: this is used in musicxml output, not in midi output
maxMidi = 16
channelFilter = []
for e in usedChannels:
if e is not None:
channelFilter.append(e)
if not channelFilter:
self.midiChannel = 0
return self.midiChannel
elif len(channelFilter) >= maxMidi:
raise InstrumentException('we are out of midi channels! help!')
elif 'UnpitchedPercussion' in self.classes and 9 not in usedChannels:
self.midiChannel = 9
return self.midiChannel
else:
for ch in range(maxMidi):
if ch in channelFilter:
continue
elif ch % 16 == 9:
continue # skip 10 / percussion for now
else:
self.midiChannel = ch
return self.midiChannel
return 0
# raise InstrumentException('we are out of midi channels and this ' +
# 'was not already detected PROGRAM BUG!')
# ------------------------------------------------------------------------------
class KeyboardInstrument(Instrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Keyboard'
self.instrumentAbbreviation = 'Kb'
self.instrumentSound = 'keyboard.piano'
class Piano(KeyboardInstrument):
'''
>>> p = instrument.Piano()
>>> p.instrumentName
'Piano'
>>> p.midiProgram
0
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Piano'
self.instrumentAbbreviation = 'Pno'
self.midiProgram = 0
self.lowestNote = pitch.Pitch('A0')
self.highestNote = pitch.Pitch('C8')
class Harpsichord(KeyboardInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Harpsichord'
self.instrumentAbbreviation = 'Hpschd'
self.midiProgram = 6
self.instrumentSound = 'keyboard.harpsichord'
self.lowestNote = pitch.Pitch('F1')
self.highestNote = pitch.Pitch('F6')
class Clavichord(KeyboardInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Clavichord'
self.instrumentAbbreviation = 'Clv'
self.midiProgram = 7
self.instrumentSound = 'keyboard.clavichord'
# TODO: self.lowestNote = pitch.Pitch('')
# TODO: self.highestNote = pitch.Pitch('')
class Celesta(KeyboardInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Celesta'
self.instrumentAbbreviation = 'Clst'
self.midiProgram = 8
self.instrumentSound = 'keyboard.celesta'
class Sampler(KeyboardInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Sampler'
self.instrumentAbbreviation = 'Samp'
self.midiProgram = 55
class ElectricPiano(Piano):
'''
>>> p = instrument.ElectricPiano()
>>> p.instrumentName
'Electric Piano'
>>> p.midiProgram
2
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Electric Piano'
self.instrumentAbbreviation = 'E.Pno'
self.midiProgram = 2
# ------------------------------------------------------------------------------
class Organ(Instrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Organ'
self.midiProgram = 19
self.instrumentSound = 'keyboard.organ'
class PipeOrgan(Organ):
def __init__(self):
super().__init__()
self.instrumentName = 'Pipe Organ'
self.instrumentAbbreviation = 'P Org'
self.midiProgram = 19
self.instrumentSound = 'keyboard.organ.pipe'
self.lowestNote = pitch.Pitch('C2')
self.highestNote = pitch.Pitch('C6')
class ElectricOrgan(Organ):
def __init__(self):
super().__init__()
self.instrumentName = 'Electric Organ'
self.instrumentAbbreviation = 'Elec Org'
self.midiProgram = 16
self.lowestNote = pitch.Pitch('C2')
self.highestNote = pitch.Pitch('C6')
class ReedOrgan(Organ):
def __init__(self):
super().__init__()
self.instrumentName = 'Reed Organ'
# TODO self.instrumentAbbreviation = ''
self.midiProgram = 20
self.instrumentSound = 'keyboard.organ.reed'
self.lowestNote = pitch.Pitch('C2')
self.highestNote = pitch.Pitch('C6')
class Accordion(Organ):
def __init__(self):
super().__init__()
self.instrumentName = 'Accordion'
self.instrumentAbbreviation = 'Acc'
self.midiProgram = 21
self.instrumentSound = 'keyboard.accordion'
self.lowestNote = pitch.Pitch('F3')
self.highestNote = pitch.Pitch('A6')
class Harmonica(Instrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Harmonica'
self.instrumentAbbreviation = 'Hmca'
self.midiProgram = 22
self.instrumentSound = 'wind.reed.harmonica'
self.lowestNote = pitch.Pitch('C3')
self.highestNote = pitch.Pitch('C6')
# -----------------------------------------------------
class StringInstrument(Instrument):
def __init__(self):
super().__init__()
self._stringPitches = None
self._cachedPitches = None
self.instrumentName = 'StringInstrument'
self.instrumentAbbreviation = 'Str'
self.midiProgram = 48
def _getStringPitches(self):
if hasattr(self, '_cachedPitches') and self._cachedPitches is not None:
return self._cachedPitches
elif not hasattr(self, '_stringPitches'):
raise InstrumentException('cannot get stringPitches for these instruments')
else:
self._cachedPitches = [pitch.Pitch(x) for x in self._stringPitches]
return self._cachedPitches
def _setStringPitches(self, newPitches):
if newPitches and (hasattr(newPitches[0], 'step') or newPitches[0] is None):
# newPitches is pitchObjects or something
self._stringPitches = newPitches
self._cachedPitches = newPitches
else:
self._cachedPitches = None
self._stringPitches = newPitches
stringPitches = property(_getStringPitches, _setStringPitches, doc='''
stringPitches is a property that stores a list of Pitches (or pitch names,
such as "C4") that represent the pitch of the open strings from lowest to
highest.[*]
>>> vln1 = instrument.Violin()
>>> [str(p) for p in vln1.stringPitches]
['G3', 'D4', 'A4', 'E5']
instrument.stringPitches are full pitch objects, not just names:
>>> [x.octave for x in vln1.stringPitches]
[3, 4, 4, 5]
Scordatura for Scelsi's violin concerto *Anahit*.
(N.B. that string to pitch conversion is happening automatically)
>>> vln1.stringPitches = ['G3', 'G4', 'B4', 'D4']
(`[*]In some tuning methods such as reentrant tuning on the ukulele,
lute, or five-string banjo the order might not strictly be from lowest to
highest. The same would hold true for certain violin scordatura pieces, such
as some of Biber's *Mystery Sonatas*`)
''')
class Violin(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Violin'
self.instrumentAbbreviation = 'Vln'
self.midiProgram = 40
self.instrumentSound = 'strings.violin'
self.lowestNote = pitch.Pitch('G3')
self._stringPitches = ['G3', 'D4', 'A4', 'E5']
class Viola(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Viola'
self.instrumentAbbreviation = 'Vla'
self.midiProgram = 41
self.instrumentSound = 'strings.viola'
self.lowestNote = pitch.Pitch('C3')
self._stringPitches = ['C3', 'G3', 'D4', 'A4']
class Violoncello(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Violoncello'
self.instrumentAbbreviation = 'Vc'
self.midiProgram = 42
self.instrumentSound = 'strings.cello'
self.lowestNote = pitch.Pitch('C2')
self._stringPitches = ['C2', 'G2', 'D3', 'A3']
class Contrabass(StringInstrument):
'''
For the Contrabass (or double bass), the stringPitches attribute refers to the sounding pitches
of each string; whereas the lowestNote attribute refers to the lowest written note.
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Contrabass'
self.instrumentAbbreviation = 'Cb'
self.midiProgram = 43
self.instrumentSound = 'strings.contrabass'
self.lowestNote = pitch.Pitch('E2')
self._stringPitches = ['E1', 'A1', 'D2', 'G2']
self.transposition = interval.Interval('P-8')
class Harp(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Harp'
self.instrumentAbbreviation = 'Hp'
self.midiProgram = 46
self.instrumentSound = 'pluck.harp'
self.lowestNote = pitch.Pitch('C1')
self.highestNote = pitch.Pitch('G#7')
class Guitar(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Guitar'
self.instrumentAbbreviation = 'Gtr'
self.midiProgram = 24 # default -- Acoustic
self.instrumentSound = 'pluck.guitar'
self.lowestNote = pitch.Pitch('E2')
self._stringPitches = ['E2', 'A2', 'D3', 'G3', 'B3', 'E4']
class AcousticGuitar(Guitar):
def __init__(self):
super().__init__()
self.instrumentName = 'Acoustic Guitar'
self.instrumentAbbreviation = 'Ac Gtr'
self.midiProgram = 24
self.instrumentSound = 'pluck.guitar.acoustic'
class ElectricGuitar(Guitar):
def __init__(self):
super().__init__()
self.instrumentName = 'Electric Guitar'
self.instrumentAbbreviation = 'Elec Gtr'
self.midiProgram = 26
self.instrumentSound = 'pluck.guitar.electric'
class AcousticBass(Guitar):
def __init__(self):
super().__init__()
self.instrumentName = 'Acoustic Bass'
self.instrumentAbbreviation = 'Ac b'
self.midiProgram = 32
self.instrumentSound = 'pluck.bass.acoustic'
self.lowestNote = pitch.Pitch('E1')
self._stringPitches = ['E1', 'A1', 'D2', 'G2']
class ElectricBass(Guitar):
def __init__(self):
super().__init__()
self.instrumentName = 'Electric Bass'
self.instrumentAbbreviation = 'Elec b'
self.midiProgram = 33
self.instrumentSound = 'pluck.bass.electric'
self.lowestNote = pitch.Pitch('E1')
self._stringPitches = ['E1', 'A1', 'D2', 'G2']
class FretlessBass(Guitar):
def __init__(self):
super().__init__()
self.instrumentName = 'Fretless Bass'
# TODO: self.instrumentAbbreviation = ''
self.midiProgram = 35
self.instrumentSound = 'pluck.bass.fretless'
self.lowestNote = pitch.Pitch('E1')
self._stringPitches = ['E1', 'A1', 'D2', 'G2']
class Mandolin(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Mandolin'
self.instrumentAbbreviation = 'Mdln'
self.instrumentSound = 'pluck.mandolin'
self.lowestNote = pitch.Pitch('G3')
self._stringPitches = ['G3', 'D4', 'A4', 'E5']
class Ukulele(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Ukulele'
self.instrumentAbbreviation = 'Uke'
self.instrumentSound = 'pluck.ukulele'
self.lowestNote = pitch.Pitch('C4')
self._stringPitches = ['G4', 'C4', 'E4', 'A4']
class Banjo(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Banjo'
self.instrumentAbbreviation = 'Bjo'
self.instrumentSound = 'pluck.banjo'
self.midiProgram = 105
self.lowestNote = pitch.Pitch('C3')
self._stringPitches = ['C3', 'G3', 'D4', 'A4']
self.transposition = interval.Interval('P-8')
class Lute(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Lute'
self.instrumentAbbreviation = 'Lte'
self.instrumentSound = 'pluck.lute'
self.midiProgram = 24
class Sitar(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Sitar'
self.instrumentAbbreviation = 'Sit'
self.instrumentSound = 'pluck.sitar'
self.midiProgram = 104
class Shamisen(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Shamisen'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'pluck.shamisen'
self.midiProgram = 106
class Koto(StringInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Koto'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'pluck.koto'
self.midiProgram = 107
# ------------------------------------------------------------------------------
class WoodwindInstrument(Instrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Woodwind'
self.instrumentAbbreviation = 'Ww'
class Flute(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Flute'
self.instrumentAbbreviation = 'Fl'
self.instrumentSound = 'wind.flutes.flute'
self.midiProgram = 73
self.lowestNote = pitch.Pitch('C4') # Occasionally (rarely) B3
class Piccolo(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Piccolo'
self.instrumentAbbreviation = 'Picc'
self.instrumentSound = 'wind.flutes.piccolo'
self.midiProgram = 72
self.lowestNote = pitch.Pitch('D4') # Occasionally (rarely) C4
self.transposition = interval.Interval('P8')
class Recorder(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Recorder'
self.instrumentAbbreviation = 'Rec'
self.instrumentSound = 'wind.flutes.recorder'
self.midiProgram = 74
self.lowestNote = pitch.Pitch('F4')
class PanFlute(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Pan Flute'
self.instrumentAbbreviation = 'P Fl'
self.instrumentSound = 'wind.flutes.panpipes'
self.midiProgram = 75
class Shakuhachi(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Shakuhachi'
self.instrumentAbbreviation = 'Shk Fl'
self.instrumentSound = 'wind.flutes.shakuhachi'
self.midiProgram = 77
class Whistle(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Whistle'
self.instrumentAbbreviation = 'Whs'
self.instrumentSound = 'wind.flutes.whistle'
self.inGMPercMap = True
self.percMapPitch = 71
self.midiProgram = 78
class Ocarina(Flute):
def __init__(self):
super().__init__()
self.instrumentName = 'Ocarina'
self.instrumentAbbreviation = 'Oc'
self.instrumentSound = 'wind.flutes.ocarina'
self.midiProgram = 79
class Oboe(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Oboe'
self.instrumentAbbreviation = 'Ob'
self.instrumentSound = 'wind.reed.oboe'
self.midiProgram = 68
self.lowestNote = pitch.Pitch('B-3')
class EnglishHorn(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'English Horn'
self.instrumentAbbreviation = 'Eng Hn'
self.instrumentSound = 'wind.reed.english-horn'
self.midiProgram = 69
self.lowestNote = pitch.Pitch('B3')
self.transposition = interval.Interval('P-5')
class Clarinet(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Clarinet'
self.instrumentAbbreviation = 'Cl'
self.instrumentSound = 'wind.reed.clarinet'
self.midiProgram = 71
self.lowestNote = pitch.Pitch('E3')
self.transposition = interval.Interval('M-2')
class BassClarinet(Clarinet):
'''
>>> bcl = instrument.BassClarinet()
>>> bcl.instrumentName
'Bass clarinet'
>>> bcl.midiProgram
71
>>> 'WoodwindInstrument' in bcl.classes
True
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Bass clarinet'
self.instrumentAbbreviation = 'Bs Cl'
self.instrumentSound = 'wind.reed.clarinet.bass'
self.lowestNote = pitch.Pitch('E-3')
self.transposition = interval.Interval('M-9')
class Bassoon(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Bassoon'
self.instrumentAbbreviation = 'Bsn'
self.instrumentSound = 'wind.reed.bassoon'
self.midiProgram = 70
self.lowestNote = pitch.Pitch('B-1')
class Contrabassoon(Bassoon):
def __init__(self):
super().__init__()
self.instrumentName = 'Contrabassoon'
self.instrumentAbbreviation = 'C Bsn'
self.instrumentSound = 'wind.reed.bassoon'
self.midiProgram = 70
self.lowestNote = pitch.Pitch('B-1')
class Saxophone(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Saxophone'
self.instrumentAbbreviation = 'Sax'
self.instrumentSound = 'wind.reed.saxophone'
self.midiProgram = 65
self.lowestNote = pitch.Pitch('B-3')
class SopranoSaxophone(Saxophone):
def __init__(self):
super().__init__()
self.instrumentName = 'Soprano Saxophone'
self.instrumentAbbreviation = 'S Sax'
self.instrumentSound = 'wind.reed.saxophone.soprano'
self.midiProgram = 64
self.transposition = interval.Interval('M-2')
class AltoSaxophone(Saxophone):
def __init__(self):
super().__init__()
self.instrumentName = 'Alto Saxophone'
self.instrumentAbbreviation = 'A Sax'
self.instrumentSound = 'wind.reed.saxophone.alto'
self.midiProgram = 65
self.transposition = interval.Interval('M-6')
class TenorSaxophone(Saxophone):
def __init__(self):
super().__init__()
self.instrumentName = 'Tenor Saxophone'
self.instrumentAbbreviation = 'T Sax'
self.instrumentSound = 'wind.reed.saxophone.tenor'
self.midiProgram = 66
self.transposition = interval.Interval('M-9')
class BaritoneSaxophone(Saxophone):
def __init__(self):
super().__init__()
self.instrumentName = 'Baritone Saxophone'
self.instrumentAbbreviation = 'Bar Sax'
self.instrumentSound = 'wind.reed.saxophone.baritone'
self.midiProgram = 67
self.transposition = interval.Interval('M-13')
class Bagpipes(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Bagpipes'
self.instrumentAbbreviation = 'Bag'
self.instrumentSound = 'wind.pipes.bagpipes'
self.midiProgram = 109
class Shehnai(WoodwindInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Shehnai'
self.instrumentAbbreviation = 'Shn'
# another spelling is 'Shehnai'
self.instrumentSound = 'wind.reed.shenai'
self.midiProgram = 111
# ------------------------------------------------------------------------------
class BrassInstrument(Instrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Brass'
self.instrumentAbbreviation = 'Brs'
self.midiProgram = 61
class Horn(BrassInstrument):
'''
>>> hn = instrument.Horn()
>>> hn.instrumentName
'Horn'
>>> hn.midiProgram
60
>>> 'BrassInstrument' in hn.classes
True
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Horn'
self.instrumentAbbreviation = 'Hn'
self.instrumentSound = 'brass.french-horn'
self.midiProgram = 60
self.lowestNote = pitch.Pitch('C2')
self.transposition = interval.Interval('P-5')
class Trumpet(BrassInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Trumpet'
self.instrumentAbbreviation = 'Tpt'
self.instrumentSound = 'brass.trumpet'
self.midiProgram = 56
self.lowestNote = pitch.Pitch('F#3')
self.transposition = interval.Interval('M-2')
class Trombone(BrassInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Trombone'
self.instrumentAbbreviation = 'Trb'
self.instrumentSound = 'brass.trombone'
self.midiProgram = 57
self.lowestNote = pitch.Pitch('E2')
class BassTrombone(Trombone):
def __init__(self):
super().__init__()
self.instrumentName = 'Bass Trombone'
self.instrumentAbbreviation = 'BTrb'
self.instrumentSound = 'brass.trombone.bass'
self.lowestNote = pitch.Pitch('B-1')
class Tuba(BrassInstrument):
def __init__(self):
super().__init__()
self.instrumentName = 'Tuba'
self.instrumentAbbreviation = 'Tba'
self.instrumentSound = 'brass.tuba'
self.midiProgram = 58
self.lowestNote = pitch.Pitch('D1')
# ------------
class Percussion(Instrument):
def __init__(self):
super().__init__()
self.inGMPercMap = False
self.percMapPitch = None
self.instrumentName = 'Percussion'
self.instrumentAbbreviation = 'Perc'
class PitchedPercussion(Percussion):
pass
class UnpitchedPercussion(Percussion):
def __init__(self):
super().__init__()
self._modifier = None
self._modifierToPercMapPitch = {}
self.midiChannel = 9 # 0-indexed, i.e. MIDI channel 10
def _getModifier(self):
return self._modifier
def _setModifier(self, modifier):
modifier = modifier.lower().strip()
# BEN: to-do, pull out hyphens, spaces, etc.
if self.inGMPercMap is True and modifier.lower() in self._modifierToPercMapPitch:
self.percMapPitch = self._modifierToPercMapPitch[modifier.lower()]
# normalize modifiers...
if self.percMapPitch in self._percMapPitchToModifier:
modifier = self._percMapPitchToModifier[self.percMapPitch]
self._modifier = modifier
modifier = property(_getModifier, _setModifier, doc='''
Returns or sets the modifier for this instrument. A modifier could
be something like "low-floor" for a TomTom or "rimshot" for a SnareDrum.
If the modifier is in the object's ._modifierToPercMapPitch dictionary
then changing the modifier also changes the .percMapPitch for the object
>>> bd = instrument.BongoDrums()
>>> bd.modifier
'high'
>>> bd.percMapPitch
60
>>> bd.modifier = 'low'
>>> bd.percMapPitch
61
Variations on modifiers can also be used and they get normalized:
>>> wb1 = instrument.Woodblock()
>>> wb1.percMapPitch
76
>>> wb1.modifier = 'LO'
>>> wb1.percMapPitch
77
>>> wb1.modifier # n.b. -- not LO
'low'
''')
class Vibraphone(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Vibraphone'
self.instrumentAbbreviation = 'Vbp'
self.instrumentSound = 'pitched-percussion.vibraphone'
self.midiProgram = 11
class Marimba(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Marimba'
self.instrumentAbbreviation = 'Mar'
self.instrumentSound = 'pitched-percussion.marimba'
self.midiProgram = 12
class Xylophone(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Xylophone'
self.instrumentAbbreviation = 'Xyl.'
self.instrumentSound = 'pitched-percussion.xylophone'
self.midiProgram = 13
class Glockenspiel(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Glockenspiel'
self.instrumentAbbreviation = 'Gsp'
self.instrumentSound = 'pitched-percussion.glockenspiel'
self.midiProgram = 9
class ChurchBells(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Church Bells'
self.instrumentAbbreviation = 'Bells'
self.instrumentSound = 'metal.bells.church'
self.midiProgram = 14
class TubularBells(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Tubular Bells'
self.instrumentAbbreviation = 'Tbells'
self.instrumentSound = 'pitched-percussion.tubular-bells'
self.midiProgram = 14
class Gong(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Gong'
self.instrumentAbbreviation = 'Gng'
self.instrumentSound = 'metal.gong'
class Handbells(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Handbells'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'pitched-percussion.handbells'
class Dulcimer(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Dulcimer'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'pluck.dulcimer'
self.midiProgram = 15
class SteelDrum(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Steel Drum'
self.instrumentAbbreviation = 'St Dr'
self.instrumentSound = 'metal.steel-drums'
self.midiProgram = 114
class Timpani(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Timpani'
self.instrumentAbbreviation = 'Timp'
self.instrumentSound = 'drum.timpani'
self.midiProgram = 47
class Kalimba(PitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Kalimba'
self.instrumentAbbreviation = 'Kal'
self.instrumentSound = 'pitched-percussion.kalimba'
self.midiProgram = 108
class Woodblock(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Woodblock'
self.instrumentAbbreviation = 'Wd Bl'
self.instrumentSound = 'wood.wood-block'
self.inGMPercMap = True
self.midiProgram = 115
self._modifier = 'high'
self._modifierToPercMapPitch = {'high': 76, 'low': 77, 'hi': 76, 'lo': 77}
self._percMapPitchToModifier = {76: 'high', 77: 'low'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class TempleBlock(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Temple Block'
self.instrumentAbbreviation = 'Temp Bl'
self.instrumentSound = 'wood.temple-block'
class Castanets(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Castanets'
self.instrumentAbbreviation = 'Cas'
self.instrumentSound = 'wood.castanets'
class Maracas(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Maracas'
self.inGMPercMap = True
self.percMapPitch = 70
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'rattle.maraca'
class Vibraslap(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Vibraslap'
self.instrumentAbbreviation = 'Vbslp'
self.instrumentSound = 'rattle.vibraslap'
self.inGMPercMap = True
self.percMapPitch = 58
# BEN: Standardize Cymbals as plural
class Cymbals(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Cymbals'
self.instrumentAbbreviation = 'Cym'
class FingerCymbals(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Finger Cymbals'
self.instrumentAbbreviation = 'Fing Cym'
self.instrumentSound = 'metal.cymbal.finger'
class CrashCymbals(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Crash Cymbals'
self.instrumentAbbreviation = 'Cym'
self.instrumentSound = 'metal.cymbal.crash'
self.inGMPercMap = True
self._modifier = '1'
self._modifierToPercMapPitch = {'1': 49,
'2': 57,
}
self._percMapPitchToModifier = {49: '1',
57: '2',
}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class SuspendedCymbal(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Suspended Cymbal'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.cymbal.suspended'
class SizzleCymbal(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Sizzle Cymbal'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.cymbal.sizzle'
class SplashCymbals(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Splash Cymbals'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.cymbal.splash'
class RideCymbals(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Ride Cymbals'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.cymbal.ride'
class HiHatCymbal(Cymbals):
def __init__(self):
super().__init__()
self.instrumentName = 'Hi-Hat Cymbal'
self.instrumentSound = 'metal.hi-hat'
self.inGMPercMap = True
self._modifier = 'pedal'
self._modifierToPercMapPitch = {'pedal': 44,
'open': 46,
'closed': 42,
}
self._percMapPitchToModifier = {44: 'pedal',
46: 'open',
42: 'closed',
}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
# TODO: self.instrumentAbbreviation = ''
class Triangle(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Triangle'
self.instrumentAbbreviation = 'Tri'
self.instrumentSound = 'metal.triangle'
self.inGMPercMap = True
self._modifier = 'open'
self._modifierToPercMapPitch = {'open': 81,
'mute': 80,
}
self._percMapPitchToModifier = {80: 'mute',
81: 'open',
}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class Cowbell(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Cowbell'
self.instrumentAbbreviation = 'Cwb'
self.instrumentSound = 'metal.bells.cowbell'
self.inGMPercMap = True
self.percMapPitch = 56
class Agogo(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Agogo'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.bells.agogo'
self.inGMPercMap = True
self.percMapPitch = 67
self.midiProgram = 113
class TamTam(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Tam-Tam'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.tamtam'
class SleighBells(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Sleigh Bells'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'metal.bells.sleigh-bells'
class SnareDrum(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Snare Drum'
self.instrumentAbbreviation = 'Sn Dr'
self.instrumentSound = 'drum.snare-drum'
self.inGMPercMap = True
self._modifier = 'acoustic'
self._modifierToPercMapPitch = {'acoustic': 38,
'side': 37,
'electric': 40,
}
self._percMapPitchToModifier = {38: 'acoustic',
37: 'side',
40: 'electric',
}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class TenorDrum(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Tenor Drum'
self.instrumentAbbreviation = 'Ten Dr'
self.instrumentSound = 'drum.tenor-drum'
class BongoDrums(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Bongo Drums'
self.instrumentAbbreviation = 'Bgo Dr'
self.instrumentSound = 'drum.bongo'
self.inGMPercMap = True
self._modifier = 'high'
self._modifierToPercMapPitch = {'high': 60, 'low': 61}
self._percMapPitchToModifier = {60: 'high', 61: 'low'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class TomTom(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Tom-Tom'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'drum.tom-tom'
self.inGMPercMap = True
self._modifier = 'low floor'
self._modifierToPercMapPitch = {'low floor': 41, 'high floor': 43, 'low': 45,
'low-mid': 47, 'high-mid': 48, 'high': 50}
self._percMapPitchToModifier = {41: 'low floor', 43: 'high floor', 45: 'low',
47: 'low-mid', 48: 'high-mid', 50: 'high'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class Timbales(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Timbales'
self.instrumentAbbreviation = 'Tim'
self.instrumentSound = 'drum.timbale'
self.inGMPercMap = True
self._modifier = 'high'
self._modifierToPercMapPitch = {'high': 65, 'low': 66}
self._percMapPitchToModifier = {65: 'high', 66: 'low'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class CongaDrum(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Conga Drum'
self.instrumentAbbreviation = 'Cga Dr'
self.instrumentSound = 'drum.conga'
self.inGMPercMap = True
self._modifier = 'low'
self._modifierToPercMapPitch = {'low': 64, 'mute high': 62, 'open high': 63}
self._percMapPitchToModifier = {64: 'low', 62: 'mute high', 63: 'open high'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class BassDrum(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Bass Drum'
self.instrumentAbbreviation = 'B Dr'
self.instrumentSound = 'drum.bass-drum'
self.inGMPercMap = True
self._modifier = 'acoustic'
self._modifierToPercMapPitch = {'acoustic': 35, '1': 36}
self._percMapPitchToModifier = {35: 'acoustic', 36: '1'}
self.percMapPitch = self._modifierToPercMapPitch[self._modifier]
class Taiko(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Taiko'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'drum.taiko'
self.midiProgram = 116
class Tambourine(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Tambourine'
self.instrumentAbbreviation = 'Tmbn'
self.instrumentSound = 'drum.tambourine'
self.inGMPercMap = True
self.percMapPitch = 54
class Whip(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Whip'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'effect.whip'
class Ratchet(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Ratchet'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'rattle.ratchet'
class Siren(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Siren'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'effect.siren'
class SandpaperBlocks(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Sandpaper Blocks'
self.instrumentAbbreviation = 'Sand Bl'
self.instrumentSound = 'wood.sand-block'
class WindMachine(UnpitchedPercussion):
def __init__(self):
super().__init__()
self.instrumentName = 'Wind Machine'
# TODO: self.instrumentAbbreviation = ''
self.instrumentSound = 'effect.wind'
# -----------------------------------------------------
class Vocalist(Instrument):
'''
n.b. called Vocalist to not be confused with stream.Voice
'''
def __init__(self):
super().__init__()
self.instrumentName = 'Voice'
self.instrumentAbbreviation = 'V'
self.midiProgram = 53
class Soprano(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Soprano'
self.instrumentAbbreviation = 'S'
self.instrumentSound = 'voice.soprano'
class MezzoSoprano(Soprano):
def __init__(self):
super().__init__()
self.instrumentName = 'Mezzo-Soprano'
self.instrumentAbbreviation = 'Mez'
self.instrumentSound = 'voice.mezzo-soprano'
class Alto(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Alto'
self.instrumentAbbreviation = 'A'
self.instrumentSound = 'voice.alto'
class Tenor(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Tenor'
self.instrumentAbbreviation = 'T'
self.instrumentSound = 'voice.tenor'
class Baritone(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Baritone'
self.instrumentAbbreviation = 'Bar'
self.instrumentSound = 'voice.baritone'
class Bass(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Bass'
self.instrumentAbbreviation = 'B'
self.instrumentSound = 'voice.bass'
class Choir(Vocalist):
def __init__(self):
super().__init__()
self.instrumentName = 'Choir'
self.instrumentAbbreviation = 'Ch'
self.instrumentSound = 'voice.choir'
self.midiProgram = 52
# -----------------------------------------------------
class Conductor(Instrument):
'''Presently used only for tracking the MIDI track containing tempo,
key signature, and related metadata.'''
def __init__(self):
super().__init__(instrumentName='Conductor')
# -----------------------------------------------------------------------------
# noinspection SpellCheckingInspection
ensembleNamesBySize = ['no performers', 'solo', 'duet', 'trio', 'quartet',
'quintet', 'sextet', 'septet', 'octet', 'nonet', 'dectet',
'undectet', 'duodectet', 'tredectet', 'quattuordectet',
'quindectet', 'sexdectet', 'septendectet', 'octodectet',
'novemdectet', 'vigetet', 'unvigetet', 'duovigetet',
'trevigetet', 'quattuorvigetet', 'quinvigetet', 'sexvigetet',
'septenvigetet', 'octovigetet', 'novemvigetet',
'trigetet', 'untrigetet', 'duotrigetet', 'tretrigetet',
'quottuortrigetet', 'quintrigetet', 'sextrigetet',
'septentrigetet', 'octotrigetet', 'novemtrigetet',
'quadragetet', 'unquadragetet', 'duoquadragetet',
'trequadragetet', 'quattuorquadragetet', 'quinquadragetet',
'sexquadragetet', 'octoquadragetet', 'octoquadragetet',
'novemquadragetet', 'quinquagetet', 'unquinquagetet',
'duoquinquagetet', 'trequinguagetet', 'quattuorquinquagetet',
'quinquinquagetet', 'sexquinquagetet', 'septenquinquagetet',
'octoquinquagetet', 'novemquinquagetet', 'sexagetet',
'undexagetet', 'duosexagetet', 'tresexagetet',
'quoattuorsexagetet', 'quinsexagetet', 'sexsexagetet',
'septensexagetet', 'octosexagetet', 'novemsexagetet',
'septuagetet', 'unseptuagetet', 'duoseptuagetet', 'treseptuagetet',
'quattuorseptuagetet', 'quinseptuagetet', 'sexseptuagetet',
'septenseptuagetet', 'octoseptuagetet', 'novemseptuagetet',
'octogetet', 'unoctogetet', 'duooctogetet',
'treoctogetet', 'quattuoroctogetet', 'quinoctogetet',
'sexoctogetet', 'septoctogetet', 'octooctogetet',
'novemoctogetet', 'nonagetet', 'unnonagetet', 'duononagetet',
'trenonagetet', 'quattuornonagetet', 'quinnonagetet',
'sexnonagetet', 'septennonagetet', 'octononagetet',
'novemnonagetet', 'centet']
def ensembleNameBySize(number):
'''
return the name of a generic ensemble with "number" players:
>>> instrument.ensembleNameBySize(4)
'quartet'
>>> instrument.ensembleNameBySize(1)
'solo'
>>> instrument.ensembleNameBySize(83)
'treoctogetet'
'''
if number > 100:
return 'large ensemble'
elif number < 0:
raise InstrumentException('okay, you are on your own for this one buddy')
else:
return ensembleNamesBySize[int(number)]
def deduplicate(s: stream.Stream, inPlace: bool = False) -> stream.Stream:
'''
Check every offset in `s` for multiple instrument instances.
If the `.partName` can be standardized across instances,
i.e. if each instance has the same value or `None`,
and likewise for `.instrumentName`, standardize the attributes.
Further, and only if the above conditions are met,
if there are two instances of the same class, remove all but one;
if at least one generic `Instrument` instance is found at the same
offset as one or more specific instruments, remove the generic `Instrument` instances.
Two `Instrument` instances:
>>> i1 = instrument.Instrument(instrumentName='Semi-Hollow Body')
>>> i2 = instrument.Instrument()
>>> i2.partName = 'Electric Guitar'
>>> s1 = stream.Stream()
>>> s1.insert(4, i1)
>>> s1.insert(4, i2)
>>> list(s1.getInstruments())
[<music21.instrument.Instrument 'Semi-Hollow Body'>,
<music21.instrument.Instrument 'Electric Guitar: '>]
>>> post = instrument.deduplicate(s1)
>>> list(post.getInstruments())
[<music21.instrument.Instrument 'Electric Guitar: Semi-Hollow Body'>]
One `Instrument` instance and one subclass instance, with `inPlace` and parts:
>>> from music21.stream import Score, Part
>>> i3 = instrument.Instrument()
>>> i3.partName = 'Piccolo'
>>> i4 = instrument.Piccolo()
>>> s2 = stream.Score()
>>> p1 = stream.Part()
>>> p1.append([i3, i4])
>>> p2 = stream.Part()
>>> p2.append([instrument.Flute(), instrument.Flute()])
>>> s2.insert(0, p1)
>>> s2.insert(0, p2)
>>> list(p1.getInstruments())
[<music21.instrument.Instrument 'Piccolo: '>, <music21.instrument.Piccolo 'Piccolo'>]
>>> list(p2.getInstruments())
[<music21.instrument.Flute 'Flute'>, <music21.instrument.Flute 'Flute'>]
>>> s2 = instrument.deduplicate(s2, inPlace=True)
>>> list(p1.getInstruments())
[<music21.instrument.Piccolo 'Piccolo: Piccolo'>]
>>> list(p2.getInstruments())
[<music21.instrument.Flute 'Flute'>]
'''
if inPlace:
returnObj = s
else:
returnObj = s.coreCopyAsDerivation('instrument.deduplicate')
if not returnObj.hasPartLikeStreams():
substreams = [returnObj]
else:
substreams = returnObj.getElementsByClass('Stream')
for sub in substreams:
oTree = OffsetTree(sub.recurse().getElementsByClass('Instrument'))
for o in oTree:
if len(o) == 1:
continue
notNonePartNames = {i.partName for i in o if i.partName is not None}
notNoneInstNames = {i.instrumentName for i in o if i.instrumentName is not None}
# Proceed only if 0-1 part name AND 0-1 instrument name candidates
if len(notNonePartNames) > 1 or len(notNoneInstNames) > 1:
continue
partName = None
for pName in notNonePartNames:
partName = pName
instrumentName = None
for iName in notNoneInstNames:
instrumentName = iName
classes = {inst.__class__ for inst in o}
# Case: 2+ instances of the same class
if len(classes) == 1:
surviving = None
# Treat first as the surviving instance and standardize name
for inst in o:
inst.partName = partName
inst.instrumentName = instrumentName
surviving = inst
break
# Remove remaining instruments
for inst in o:
if inst is surviving:
continue
sub.remove(inst, recurse=True)
# Case: mixed classes: standardize names
# Remove instances of generic `Instrument` if found
else:
for inst in o:
if inst.__class__ == Instrument:
sub.remove(inst, recurse=True)
else:
inst.partName = partName
inst.instrumentName = instrumentName
return returnObj
# For lookup by MIDI Program
# TODOs should be resolved with another mapping from MIDI program
# to .instrumentSound
MIDI_PROGRAM_TO_INSTRUMENT = {
0: Piano,
1: Piano,
2: ElectricPiano,
3: Piano,
4: ElectricPiano,
5: ElectricPiano,
6: Harpsichord,
7: Clavichord,
8: Celesta,
9: Glockenspiel,
10: Glockenspiel, # TODO: MusicBox
11: Vibraphone,
12: Marimba,
13: Xylophone,
14: TubularBells,
15: Dulcimer,
16: ElectricOrgan, # TODO: instrumentSound
17: ElectricOrgan, # TODO: instrumentSound
18: ElectricOrgan, # TODO: instrumentSound
19: PipeOrgan,
20: ReedOrgan,
21: Accordion,
22: Harmonica,
23: Accordion, # TODO: instrumentSound
24: AcousticGuitar, # TODO: instrumentSound
25: AcousticGuitar, # TODO: instrumentSound
26: ElectricGuitar, # TODO: instrumentSound
27: ElectricGuitar, # TODO: instrumentSound
28: ElectricGuitar, # TODO: instrumentSound
29: ElectricGuitar, # TODO: instrumentSound
30: ElectricGuitar, # TODO: instrumentSound
31: ElectricGuitar, # TODO: instrumentSound
32: AcousticBass,
33: ElectricBass,
34: ElectricBass, # TODO: instrumentSound
35: FretlessBass,
36: ElectricBass, # TODO: instrumentSound
37: ElectricBass, # TODO: instrumentSound
38: ElectricBass, # TODO: instrumentSound
39: ElectricBass, # TODO: instrumentSound
40: Violin,
41: Viola,
42: Violoncello,
43: Contrabass,
44: StringInstrument, # TODO: instrumentSound
45: StringInstrument, # TODO: instrumentSound
46: Harp,
47: Timpani,
48: StringInstrument, # TODO: instrumentSound
49: StringInstrument, # TODO: instrumentSound
50: StringInstrument, # TODO: instrumentSound
51: StringInstrument, # TODO: instrumentSound
52: Choir, # TODO: instrumentSound
53: Vocalist, # TODO: instrumentSound
54: Vocalist, # TODO: instrumentSound
55: Sampler,
56: Trumpet,
57: Trombone,
58: Tuba,
59: Trumpet, # TODO: instrumentSound
60: Horn,
61: BrassInstrument, # TODO: instrumentSound
62: BrassInstrument, # TODO: instrumentSound
63: BrassInstrument, # TODO: instrumentSound
64: SopranoSaxophone,
65: AltoSaxophone,
66: TenorSaxophone,
67: BaritoneSaxophone,
68: Oboe,
69: EnglishHorn,
70: Bassoon,
71: Clarinet,
72: Piccolo,
73: Flute,
74: Recorder,
75: PanFlute,
76: PanFlute, # TODO 76: Bottle
77: Shakuhachi,
78: Whistle,
79: Ocarina,
80: Sampler, # TODO: all Sampler here and below: instrumentSound
81: Sampler,
82: Sampler,
83: Sampler,
84: Sampler,
85: Sampler,
86: Sampler,
87: Sampler,
88: Sampler,
89: Sampler,
90: Sampler,
91: Sampler,
92: Sampler,
93: Sampler,
94: Sampler,
95: Sampler,
96: Sampler,
97: Sampler,
98: Sampler,
99: Sampler,
100: Sampler,
101: Sampler,
102: Sampler,
103: Sampler,
104: Sitar,
105: Banjo,
106: Shamisen,
107: Koto,
108: Kalimba,
109: Bagpipes,
110: Violin, # TODO: instrumentSound
111: Shehnai,
112: Glockenspiel, # TODO 112: Tinkle Bell
113: Agogo,
114: SteelDrum,
115: Woodblock,
116: Taiko,
117: TomTom,
118: Sampler, # TODO: instrumentSound # debatable if this should be drum?
119: Sampler,
120: Sampler,
121: Sampler,
122: Sampler,
123: Sampler,
124: Sampler,
125: Sampler,
126: Sampler,
127: Sampler
}
def instrumentFromMidiProgram(number: int) -> Instrument:
'''
Return the instrument with "number" as its assigned MIDI program.
Notice any of the values 0-5 will return Piano.
Lookups are performed against `instrument.MIDI_PROGRAM_TO_INSTRUMENT`.
>>> instrument.instrumentFromMidiProgram(4)
<music21.instrument.ElectricPiano 'Electric Piano'>
>>> instrument.instrumentFromMidiProgram(21)
<music21.instrument.Accordion 'Accordion'>
>>> instrument.instrumentFromMidiProgram(500)
Traceback (most recent call last):
music21.exceptions21.InstrumentException: No instrument found for MIDI program 500
>>> instrument.instrumentFromMidiProgram('43')
Traceback (most recent call last):
TypeError: Expected int, got <class 'str'>
'''
try:
class_ = MIDI_PROGRAM_TO_INSTRUMENT[number]
inst = class_()
inst.midiProgram = number
# TODO: if midiProgram in MIDI_PROGRAM_SOUND_MAP:
# inst.instrumentSound = MIDI_PROGRAM_SOUND_MAP[midiProgram]
except KeyError as e:
if not isinstance(number, int):
raise TypeError(f'Expected int, got {type(number)}') from e
raise InstrumentException(f'No instrument found for MIDI program {number}') from e
return inst
def partitionByInstrument(streamObj):
# noinspection PyShadowingNames
'''
Given a single Stream, or a Score or similar multi-part structure,
partition into a Part for each unique Instrument, joining events
possibly from different parts.
>>> p1 = converter.parse("tinynotation: 4/4 c4 d e f g a b c' c1")
>>> p2 = converter.parse("tinynotation: 4/4 C#4 D# E# F# G# A# B# c# C#1")
>>> p1.getElementsByClass('Measure')[0].insert(0.0, instrument.Piccolo())
>>> p1.getElementsByClass('Measure')[0].insert(2.0, instrument.AltoSaxophone())
>>> p1.getElementsByClass('Measure')[1].insert(3.0, instrument.Piccolo())
>>> p2.getElementsByClass('Measure')[0].insert(0.0, instrument.Trombone())
>>> p2.getElementsByClass('Measure')[0].insert(3.0, instrument.Piccolo()) # not likely...
>>> p2.getElementsByClass('Measure')[1].insert(1.0, instrument.Trombone())
>>> s = stream.Score()
>>> s.insert(0, p1)
>>> s.insert(0, p2)
>>> s.show('text')
{0.0} <music21.stream.Part ...>
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.instrument.Piccolo 'Piccolo'>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C>
{1.0} <music21.note.Note D>
{2.0} <music21.instrument.AltoSaxophone 'Alto Saxophone'>
{2.0} <music21.note.Note E>
{3.0} <music21.note.Note F>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Note G>
{1.0} <music21.note.Note A>
{2.0} <music21.note.Note B>
{3.0} <music21.instrument.Piccolo 'Piccolo'>
{3.0} <music21.note.Note C>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Note C>
{4.0} <music21.bar.Barline type=final>
{0.0} <music21.stream.Part ...>
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.instrument.Trombone 'Trombone'>
{0.0} <music21.clef.BassClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C#>
{1.0} <music21.note.Note D#>
{2.0} <music21.note.Note E#>
{3.0} <music21.instrument.Piccolo 'Piccolo'>
{3.0} <music21.note.Note F#>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Note G#>
{1.0} <music21.instrument.Trombone 'Trombone'>
{1.0} <music21.note.Note A#>
{2.0} <music21.note.Note B#>
{3.0} <music21.note.Note C#>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Note C#>
{4.0} <music21.bar.Barline type=final>
>>> s2 = instrument.partitionByInstrument(s)
>>> len(s2.parts)
3
# TODO: this step might not be necessary...
>>> for p in s2.parts:
... p.makeRests(fillGaps=True, inPlace=True)
# TODO: this step SHOULD not be necessary (.template())...
>>> for p in s2.parts:
... p.makeMeasures(inPlace=True)
... p.makeTies(inPlace=True)
>>> s2.show('text')
{0.0} <music21.stream.Part Piccolo>
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.instrument.Piccolo 'Piccolo'>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C>
{1.0} <music21.note.Note D>
{2.0} <music21.note.Rest quarter>
{3.0} <music21.note.Note F#>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Note G#>
{1.0} <music21.note.Rest half>
{3.0} <music21.note.Note C>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Note C>
{4.0} <music21.bar.Barline type=final>
{0.0} <music21.stream.Part Alto Saxophone>
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.instrument.AltoSaxophone 'Alto Saxophone'>
{0.0} <music21.clef.TrebleClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Rest half>
{2.0} <music21.note.Note E>
{3.0} <music21.note.Note F>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Note G>
{1.0} <music21.note.Note A>
{2.0} <music21.note.Note B>
{3.0} <music21.bar.Barline type=final>
{0.0} <music21.stream.Part Trombone>
{0.0} <music21.stream.Measure 1 offset=0.0>
{0.0} <music21.instrument.Trombone 'Trombone'>
{0.0} <music21.clef.BassClef>
{0.0} <music21.meter.TimeSignature 4/4>
{0.0} <music21.note.Note C#>
{1.0} <music21.note.Note D#>
{2.0} <music21.note.Note E#>
{3.0} <music21.note.Rest quarter>
{4.0} <music21.stream.Measure 2 offset=4.0>
{0.0} <music21.note.Rest quarter>
{1.0} <music21.note.Note A#>
{2.0} <music21.note.Note B#>
{3.0} <music21.note.Note C#>
{8.0} <music21.stream.Measure 3 offset=8.0>
{0.0} <music21.note.Note C#>
{4.0} <music21.bar.Barline type=final>
TODO: parts should be in Score Order. Coincidence that this almost works.
TODO: use proper recursion to make a copy of the stream.
TODO: final barlines should be aligned.
'''
if not streamObj.hasPartLikeStreams():
# place in a score for uniform operations
s = stream.Score()
s.insert(0, streamObj.flatten())
else:
s = stream.Score()
# append flat parts
for sub in streamObj.getElementsByClass(stream.Stream):
s.insert(0, sub.flatten())
# first, let's extend the duration of each instrument to match stream
for sub in s.getElementsByClass(stream.Stream):
sub.extendDuration('Instrument', inPlace=True)
# first, find all unique instruments
instrumentIterator = s.recurse().getElementsByClass(Instrument)
if not instrumentIterator:
# TODO(msc): v7 return s.
return None # no partition is available
names = OrderedDict() # store unique names
for instrumentObj in instrumentIterator:
# matching here by instrument name
if instrumentObj.instrumentName not in names:
names[instrumentObj.instrumentName] = {'Instrument': instrumentObj}
# just store one instance
# create a return object that has a part for each instrument
post = stream.Score()
for iName in names:
p = stream.Part()
p.id = iName
# add the instrument instance
p.insert(0, names[iName]['Instrument'])
# store a handle to this part
names[iName]['Part'] = p
post.insert(0, p)
# iterate over flat sources; get events within each defined instrument
# add to corresponding part
for el in s:
if not el.isStream:
post.insert(el.offset, el)
subStream = el
for i in subStream.getElementsByClass(Instrument):
start = i.offset
# duration will have been set with sub.extendDuration above
end = i.offset + i.duration.quarterLength
# get destination Part
p = names[i.instrumentName]['Part']
coll = subStream.getElementsByOffset(
start,
end,
# do not include elements that start at the end
includeEndBoundary=False,
mustFinishInSpan=False,
mustBeginInSpan=True
)
# add to part at original offset
# do not gather instrument
for e in coll.getElementsNotOfClass(Instrument):
try:
p.insert(subStream.elementOffset(e), e)
except stream.StreamException:
pass
# it is possible to enter an element twice because the getElementsByOffset
# might return something twice if it's at the same offset as the
# instrument switch...
for inst in post.recurse().getElementsByClass(Instrument):
inst.duration.quarterLength = 0
return post
def _combinations(instrumentString):
'''
find all combinations of instrumentString. Remove all punctuation.
'''
sampleList = instrumentString.split()
allComb = []
for size in range(1, len(sampleList) + 1):
for i in range(len(sampleList) - size + 1):
allComb.append(' '.join(sampleList[i:i + size]))
return allComb
def fromString(instrumentString):
'''
Given a string with instrument content (from an orchestral score
for example), attempts to return an appropriate
:class:`~music21.instrument.Instrument`.
>>> from music21 import instrument
>>> t1 = instrument.fromString('Clarinet 2 in A')
>>> t1
<music21.instrument.Clarinet 'Clarinet 2 in A'>
>>> t1.transposition
<music21.interval.Interval m-3>
>>> t2 = instrument.fromString('Clarinetto 3')
>>> t2
<music21.instrument.Clarinet 'Clarinetto 3'>
>>> t3 = instrument.fromString('flauto 2')
>>> t3
<music21.instrument.Flute 'flauto 2'>
Excess information is ignored, and the useful information can be extracted
correctly as long as it's sequential.
>>> t4 = instrument.fromString('I <3 music saxofono tenore go beavers')
>>> t4
<music21.instrument.TenorSaxophone 'I <3 music saxofono tenore go beavers'>
Some more demos:
>>> t5 = instrument.fromString('Bb Clarinet')
>>> t5
<music21.instrument.Clarinet 'Bb Clarinet'>
>>> t5.transposition
<music21.interval.Interval M-2>
>>> t6 = instrument.fromString('Clarinet in B-flat')
>>> t5.__class__ == t6.__class__
True
>>> t5.transposition == t6.transposition
True
>>> t7 = instrument.fromString('B-flat Clarinet.')
>>> t5.__class__ == t7.__class__ and t5.transposition == t7.transposition
True
>>> t8 = instrument.fromString('Eb Clarinet')
>>> t5.__class__ == t8.__class__
True
>>> t8.transposition
<music21.interval.Interval m3>
Note that because of the ubiquity of B-flat clarinets and trumpets, and the
rareness of B-natural forms of those instruments, this gives a B-flat, not
B-natural clarinet, using the German form:
>>> t9 = instrument.fromString('Klarinette in B.')
>>> t9
<music21.instrument.Clarinet 'Klarinette in B.'>
>>> t9.transposition
<music21.interval.Interval M-2>
Use "H" or "b-natural" to get an instrument in B-major. Or donate one to me
and I'll change this back!
Finally, standard abbreviations are acceptable:
>>> t10 = instrument.fromString('Cl in B-flat')
>>> t10
<music21.instrument.Clarinet 'Cl in B-flat'>
>>> t10.transposition
<music21.interval.Interval M-2>
This should work with or without a terminal period (for both 'Cl' and 'Cl.'):
>>> t11 = instrument.fromString('Cl. in B-flat')
>>> t11.__class__ == t10.__class__
True
Previously an exact instrument name was not always working:
>>> instrument.fromString('Flute')
<music21.instrument.Flute 'Flute'>
This common MIDI instrument was not previously working:
>>> instrument.fromString('Choir (Aahs)')
<music21.instrument.Choir 'Choir (Aahs)'>
'''
# pylint: disable=undefined-variable
from music21.languageExcerpts import instrumentLookup
instrumentStringOrig = instrumentString
instrumentString = instrumentString.replace('.', ' ') # sic, before removePunctuation
instrumentString = common.removePunctuation(instrumentString)
allCombinations = _combinations(instrumentString)
# First task: Find the best instrument.
bestInstClass = None
bestInstrument = None
bestName = None
for substring in allCombinations:
substring = substring.lower()
try:
if substring in instrumentLookup.bestNameToInstrumentClass:
englishName = substring
else:
englishName = instrumentLookup.allToBestName[substring]
className = instrumentLookup.bestNameToInstrumentClass[englishName]
# This would be unsafe...
thisInstClass = globals()[className]
thisInstClassParentClasses = [parentCls.__name__ for parentCls in thisInstClass.mro()]
# if not for this...
if ('Instrument' not in thisInstClassParentClasses
or 'Music21Object' not in thisInstClassParentClasses):
# little bit of security against calling another global...
raise KeyError
thisInstrument = thisInstClass()
thisBestName = thisInstrument.bestName().lower()
if (bestInstClass is None
or len(thisBestName.split()) >= len(bestName.split())
and not issubclass(bestInstClass, thisInstClass)):
# priority is also given to same length instruments which fall later
# on in the string (i.e. Bb Piccolo Trumpet)
bestInstClass = thisInstClass
bestInstrument = thisInstrument
bestInstrument.instrumentName = instrumentStringOrig
bestName = thisBestName
except KeyError:
pass
if bestInstClass is None:
raise InstrumentException(
f'Could not match string with instrument: {instrumentStringOrig}')
if bestName not in instrumentLookup.transposition:
return bestInstrument
# A transposition table is defined for the instrument.
# Second task: Determine appropriate transposition (if any)
for substring in allCombinations:
try:
bestPitch = instrumentLookup.pitchFullNameToName[substring.lower()]
bestInterval = instrumentLookup.transposition[bestName][bestPitch]
bestInstrument.transposition = interval.Interval(bestInterval)
break
except KeyError:
pass
return bestInstrument
# ------------------------------------------------------------------------------
class TestExternal(unittest.TestCase):
pass
class Test(unittest.TestCase):
def testCopyAndDeepcopy(self):
'''Test copying all objects defined in this module
'''
import types
for part in sys.modules[self.__module__].__dict__.keys():
match = False
for skip in ['_', '__', 'Test', 'Exception']:
if part.startswith(skip) or part.endswith(skip):
match = True
if match:
continue
name = getattr(sys.modules[self.__module__], part)
# noinspection PyTypeChecker
if callable(name) and not isinstance(name, types.FunctionType):
try: # see if obj can be made w/ args
obj = name()
except TypeError: # pragma: no cover
continue
i = copy.copy(obj)
j = copy.deepcopy(obj)
def testMusicXMLExport(self):
s1 = stream.Stream()
i1 = Violin()
i1.partName = 'test'
s1.append(i1)
s1.repeatAppend(note.Note(), 10)
# s.show()
s2 = stream.Stream()
i2 = Piano()
i2.partName = 'test2'
s2.append(i2)
s2.repeatAppend(note.Note('g4'), 10)
s3 = stream.Score()
s3.insert(0, s1)
s3.insert(0, s2)
# s3.show()
def testPartitionByInstrumentA(self):
from music21 import instrument
# basic case of instruments in Parts
s = stream.Score()
p1 = stream.Part()
p1.append(instrument.Piano())
p2 = stream.Part()
p2.append(instrument.Piccolo())
s.insert(0, p1)
s.insert(0, p2)
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 2)
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 2)
# post.show('t')
# one Stream with multiple instruments
s = stream.Stream()
s.insert(0, instrument.PanFlute())
s.insert(20, instrument.ReedOrgan())
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 2)
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 2)
# post.show('t')
def testPartitionByInstrumentB(self):
from music21 import instrument
# basic case of instruments in Parts
s = stream.Score()
p1 = stream.Part()
p1.append(instrument.Piano())
p1.repeatAppend(note.Note(), 6)
p2 = stream.Part()
p2.append(instrument.Piccolo())
p2.repeatAppend(note.Note(), 12)
s.insert(0, p1)
s.insert(0, p2)
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 2)
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 2)
self.assertEqual(len(post.parts[0].notes), 6)
self.assertEqual(len(post.parts[1].notes), 12)
def testPartitionByInstrumentC(self):
from music21 import instrument
# basic case of instruments in Parts
s = stream.Score()
p1 = stream.Part()
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('a'), 6)
# will go in next available offset
p1.append(instrument.AcousticGuitar())
p1.repeatAppend(note.Note('b'), 3)
p2 = stream.Part()
p2.append(instrument.Piccolo())
p2.repeatAppend(note.Note('c'), 2)
p2.append(instrument.Flute())
p2.repeatAppend(note.Note('d'), 4)
s.insert(0, p1)
s.insert(0, p2)
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 4) # 4 instruments
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 4)
self.assertEqual(post.parts[0].getInstrument().instrumentName, 'Piano')
self.assertEqual(len(post.parts[0].notes), 6)
self.assertEqual(post.parts[1].getInstrument().instrumentName, 'Acoustic Guitar')
self.assertEqual(len(post.parts[1].notes), 3)
self.assertEqual(post.parts[2].getInstrument().instrumentName, 'Piccolo')
self.assertEqual(len(post.parts[2].notes), 2)
self.assertEqual(post.parts[3].getInstrument().instrumentName, 'Flute')
self.assertEqual(len(post.parts[3].notes), 4)
# environLocal.printDebug(['post processing'])
# post.show('t')
def testPartitionByInstrumentD(self):
from music21 import instrument
# basic case of instruments in Parts
s = stream.Score()
p1 = stream.Part()
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('a'), 6)
# will go in next available offset
p1.append(instrument.AcousticGuitar())
p1.repeatAppend(note.Note('b'), 3)
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('e'), 5)
p2 = stream.Part()
p2.append(instrument.Piccolo())
p2.repeatAppend(note.Note('c'), 2)
p2.append(instrument.Flute())
p2.repeatAppend(note.Note('d'), 4)
p2.append(instrument.Piano())
p2.repeatAppend(note.Note('f'), 1)
s.insert(0, p1)
s.insert(0, p2)
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 4) # 4 instruments
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 4)
# piano spans are joined together
self.assertEqual(post.parts[0].getInstrument().instrumentName, 'Piano')
self.assertEqual(len(post.parts[0].notes), 12)
self.assertEqual([n.offset for n in post.parts[0].notes],
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 9.0, 10.0, 11.0, 12.0, 13.0])
# environLocal.printDebug(['post processing'])
# post.show('t')
def testPartitionByInstrumentE(self):
from music21 import instrument
# basic case of instruments in Parts
# s = stream.Score()
p1 = stream.Part()
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('a'), 6)
# will go in next available offset
p1.append(instrument.AcousticGuitar())
p1.repeatAppend(note.Note('b'), 3)
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('e'), 5)
p1.append(instrument.Piccolo())
p1.repeatAppend(note.Note('c'), 2)
p1.append(instrument.Flute())
p1.repeatAppend(note.Note('d'), 4)
p1.append(instrument.Piano())
p1.repeatAppend(note.Note('f'), 1)
s = p1
post = instrument.partitionByInstrument(s)
self.assertEqual(len(post), 4) # 4 instruments
self.assertEqual(len(post.flatten().getElementsByClass('Instrument')), 4)
# piano spans are joined together
self.assertEqual(post.parts[0].getInstrument().instrumentName, 'Piano')
self.assertEqual(len(post.parts[0].notes), 12)
offsetList = []
ppn = post.parts[0].notes
for n in ppn:
offsetList.append(n.offset)
self.assertEqual(offsetList,
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 9.0, 10.0, 11.0, 12.0, 13.0, 20.0])
def testPartitionByInstrumentF(self):
from music21 import instrument
s1 = stream.Stream()
s1.append(instrument.AcousticGuitar())
s1.append(note.Note())
s1.append(instrument.Tuba())
s1.append(note.Note())
post = instrument.partitionByInstrument(s1)
self.assertEqual(len(post), 2) # 4 instruments
# def testPartitionByInstrumentDocTest(self):
# '''
# For debugging the doctest.
# '''
# from music21 import instrument, converter, stream
# p1 = converter.parse("tinynotation: 4/4 c4 d e f g a b c' c1")
# p2 = converter.parse("tinynotation: 4/4 C#4 D# E# F# G# A# B# c# C#1")
#
# p1.getElementsByClass('Measure')[0].insert(0.0, instrument.Piccolo())
# p1.getElementsByClass('Measure')[0].insert(2.0, instrument.AltoSaxophone())
# p1.getElementsByClass('Measure')[1].insert(3.0, instrument.Piccolo())
#
# p2.getElementsByClass('Measure')[0].insert(0.0, instrument.Trombone())
# p2.getElementsByClass('Measure')[0].insert(3.0, instrument.Piccolo()) # not likely...
# p2.getElementsByClass('Measure')[1].insert(1.0, instrument.Trombone())
#
# s = stream.Score()
# s.insert(0, p1)
# s.insert(0, p2)
# s2 = instrument.partitionByInstrument(s)
# for p in s2.parts:
# p.makeRests(fillGaps=True, inPlace=True)
# ------------------------------------------------------------------------------
# define presented order in documentation
_DOC_ORDER = [Instrument]
if __name__ == '__main__':
# sys.arg test options will be used in mainTest()
import music21
music21.mainTest(Test)
|
overholt/stores/forms.py | prdonahue/overholt | 1,152 | 11099704 | <gh_stars>1000+
# -*- coding: utf-8 -*-
"""
overholt.stores.forms
~~~~~~~~~~~~~~~~~~~~~
Store forms
"""
from flask_wtf import Form, TextField, Required, Optional
__all__ = ['NewStoreForm', 'UpdateStoreForm']
class NewStoreForm(Form):
name = TextField('Name', validators=[Required()])
address = TextField('Address', validators=[Required()])
city = TextField('City', validators=[Required()])
state = TextField('State', validators=[Required()])
zip_code = TextField('Zip Code', validators=[Required()])
class UpdateStoreForm(Form):
name = TextField('Name', validators=[Optional()])
address = TextField('Address', validators=[Optional()])
city = TextField('City', validators=[Optional()])
state = TextField('State', validators=[Optional()])
zip_code = TextField('Zip Code', validators=[Optional()])
|
DQM/TrackingMonitorSource/python/pixelTracksMonitoring_cff.py | malbouis/cmssw | 852 | 11099711 | import FWCore.ParameterSet.Config as cms
from DQM.TrackingMonitor.TrackerCollisionTrackingMonitor_cfi import *
pixelTracksMonitor = TrackerCollisionTrackMon.clone(
FolderName = 'Tracking/PixelTrackParameters/pixelTracks',
TrackProducer = 'pixelTracks',
allTrackProducer = 'pixelTracks',
beamSpot = 'offlineBeamSpot',
primaryVertex = 'pixelVertices',
pvNDOF = 1,
doAllPlots = False,
doLumiAnalysis = True,
doProfilesVsLS = True,
doDCAPlots = True,
doEffFromHitPatternVsPU = False,
doEffFromHitPatternVsBX = False,
doEffFromHitPatternVsLUMI = False,
doPlotsVsGoodPVtx = True,
doPlotsVsLUMI = True,
doPlotsVsBX = True
)
_trackSelector = cms.EDFilter('TrackSelector',
src = cms.InputTag('pixelTracks'),
cut = cms.string("")
)
quality = {
"L" : "loose",
"T" : "tight",
"HP" : "highPurity",
}
for key,value in quality.items():
label = "pixelTrks"+key
# print label
cutstring = "quality('" + value + "')"
# print cutstring
if label not in globals():
locals()[label] = _trackSelector.clone( cut = cutstring )
locals()[label].setLabel(label)
else :
print(label,"already configured")
for key,value in quality.items():
label = "pixelTrksMonitor"+key
locals()[label] = pixelTracksMonitor.clone(
TrackProducer = "pixelTrks"+key,
FolderName = "Tracking/PixelTrackParameters/"+value
)
locals()[label].setLabel(label)
ntuplet = {
'3' : "3Hits", # ==3
'4' : "4Hits" # >=4
}
for kN,vN in ntuplet.items():
for key,value in quality.items():
label = "pixelTrks" + vN + key
# print label
cutstring = "numberOfValidHits == " + kN + " & quality('" + value + "')"
# print cutstring
locals()[label] = _trackSelector.clone( cut = cutstring )
locals()[label].setLabel(label)
for kN,vN in ntuplet.items():
for key,value in quality.items():
label = "pixelTrks" + vN + "Monitor" + key
# print label
locals()[label] = pixelTracksMonitor.clone(
TrackProducer = "pixelTrks" + vN + key,
FolderName = "Tracking/PixelTrackParameters/" + vN + "/" + value
)
locals()[label].setLabel(label)
from CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi import goodOfflinePrimaryVertices as _goodOfflinePrimaryVertices
goodPixelVertices = _goodOfflinePrimaryVertices.clone(
src = "pixelVertices"
)
from DQM.TrackingMonitor.primaryVertexResolution_cfi import primaryVertexResolution as _primaryVertexResolution
pixelVertexResolution = _primaryVertexResolution.clone(
vertexSrc = "goodPixelVertices",
rootFolder = "OfflinePixelPV/Resolution"
)
pixelTracksMonitoringTask = cms.Task(
goodPixelVertices,
)
for category in ["pixelTrks", "pixelTrks3Hits", "pixelTrks4Hits"]:
for key in quality:
label = category+key
# print label
pixelTracksMonitoringTask.add(locals()[label])
allPixelTracksMonitoring = cms.Sequence()
for category in ["pixelTrksMonitor", "pixelTrks3HitsMonitor", "pixelTrks4HitsMonitor" ]:
for key in quality:
label = category+key
# print label
allPixelTracksMonitoring += locals()[label]
pixelTracksMonitoring = cms.Sequence(
allPixelTracksMonitoring +
pixelVertexResolution,
pixelTracksMonitoringTask
)
|
machine/models/__init__.py | drdarina/slack-machine | 111 | 11099719 | <gh_stars>100-1000
from .channel import Channel # noqa
from .user import User # noqa
|
python/minicaffe/profiler.py | ktts16/mini-caffe | 413 | 11099724 | <filename>python/minicaffe/profiler.py
# coding = utf-8
# pylint: disable=invalid-name
"""Profiler in mini-caffe"""
from .base import LIB
from .base import c_str, check_call
class Profiler(object):
"""Profiler
"""
@staticmethod
def enable():
"""enable profiler
"""
check_call(LIB.CaffeProfilerEnable())
@staticmethod
def disable():
"""disable profiler
"""
check_call(LIB.CaffeProfilerDisable())
@staticmethod
def open_scope(name):
"""open a scope on profiler
Parameters
----------
name: string
scope name
"""
check_call(LIB.CaffeProfilerScopeStart(c_str(name)))
@staticmethod
def close_scope():
"""close a scope on profiler
"""
check_call(LIB.CaffeProfilerScopeEnd())
@staticmethod
def dump(fn):
"""dump profiler data to fn
Parameters
----------
fn: string
file path to save profiler data
"""
check_call(LIB.CaffeProfilerDump(c_str(fn)))
|
backend/lk/views/reviews.py | Purus/LaunchKitDocker | 2,341 | 11099770 | <filename>backend/lk/views/reviews.py
#
# Copyright 2016 Cluster Labs, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import logging
import urlparse
from django import forms
from django.core import validators
from backend.lk.logic import appstore
from backend.lk.logic import appstore_app_info
from backend.lk.logic import appstore_review_notify
from backend.lk.logic import appstore_review_subscriptions
from backend.lk.models import AppStoreApp
from backend.lk.models import AppStoreReview
from backend.lk.models import TwitterAppConnection
from backend.lk.views.base import api_response
from backend.lk.views.base import api_view
from backend.lk.views.base import api_user_view
from backend.lk.views.base import bad_request
from backend.lk.views.base import not_found
from backend.lk.views.base import ok_response
from backend.util import lkforms
class NewSubscriptionForm(forms.Form):
email = lkforms.LKEmailField(required=False)
my_email = lkforms.LKBooleanField(required=False)
twitter_app_connection_id = lkforms.LKEncryptedIdReferenceField(TwitterAppConnection, required=False)
app_id = lkforms.LKEncryptedIdReferenceField(AppStoreApp, required=False)
slack_channel_name = forms.CharField(required=False, max_length=64)
slack_url = forms.URLField(required=False)
def clean_slack_url(self):
slack_url = self.cleaned_data.get('slack_url')
if slack_url:
if urlparse.urlparse(slack_url).netloc != 'hooks.slack.com' or '/services/' not in slack_url:
raise forms.ValidationError('Slack URL should be a hooks.slack.com URL and start with /services/.')
return slack_url
def clean(self):
email = self.cleaned_data.get('email')
slack_url = self.cleaned_data.get('slack_url')
my_email = self.cleaned_data.get('my_email', False)
slack_channel_name = self.cleaned_data.get('slack_channel_name', False)
twitter_app_connection = self.cleaned_data.get('twitter_app_connection_id')
app = self.cleaned_data.get('app_id')
# the form is considered legit if it contains just one of the parameters for creating a review subsciption
legit = len(filter(lambda x: x, [slack_url, email, my_email, slack_channel_name, twitter_app_connection, app])) == 1
if not legit:
raise forms.ValidationError(
'Please provide `email` or `slack_url` or `my_email` or `slack_channel` or `twitter_app_connection_id` or `app_id`, but just one.')
return self.cleaned_data
class ReviewsFilter(forms.Form):
start_review_id = lkforms.LKEncryptedIdReferenceField(AppStoreReview, required=False)
app_id = lkforms.LKEncryptedIdReferenceField(AppStoreApp, required=False)
country = forms.ChoiceField(choices=appstore.APPSTORE_COUNTRIES, required=False)
rating = forms.IntegerField(required=False, min_value=1, max_value=5)
limit = forms.IntegerField(required=False, min_value=1, max_value=200)
@api_user_view('GET')
def reviews_view(request):
form = ReviewsFilter(request.GET)
if not form.is_valid():
return bad_request('Invalid filters provided.', errors=form.errors)
filters = form.cleaned_data
start_review = filters.get('start_review_id')
my_reviews = appstore_review_subscriptions.subscribed_reviews_for_user(request.user,
app=filters.get('app_id'),
country=filters.get('country'),
rating=filters.get('rating'),
start_review=start_review,
limit=filters.get('limit'))
# TODO(Taylor): Remove app id:app 1:1 relationship; move to app id + country
apps = set()
for review in my_reviews:
if review.app not in apps:
apps.add(review.app)
return api_response({
'reviews': [r.to_dict() for r in my_reviews],
'apps': dict((a.encrypted_id, a.to_dict()) for a in apps),
})
@api_view('GET')
def review_view(request, review_id=None):
review = AppStoreReview.find_by_encrypted_id(review_id)
if not review:
return not_found()
app = review.app
appstore_app_info.decorate_app(app, review.country)
return api_response({
'review': review.to_dict(),
'apps': {app.encrypted_id: app.to_dict()}
})
@api_user_view('GET', 'POST')
def subscriptions_view(request):
if request.method == 'GET':
return _subscriptions_view_GET(request)
else:
return _subscriptions_view_POST(request)
def _subscriptions_view_GET(request):
my_subscriptions = appstore_review_subscriptions.subscriptions_for_user(request.user)
return api_response({
'subscriptions': [s.to_dict() for s in my_subscriptions],
})
def _subscriptions_view_POST(request):
form = NewSubscriptionForm(request.POST)
if not form.is_valid():
return bad_request('Invalid subscription data.', errors=form.errors)
email = form.cleaned_data.get('email')
my_email = form.cleaned_data.get('my_email')
slack_url = form.cleaned_data.get('slack_url')
slack_channel_name = form.cleaned_data.get('slack_channel_name')
twitter_app_connection = form.cleaned_data.get('twitter_app_connection_id')
app = form.cleaned_data.get('app_id')
if app and not twitter_app_connection:
try:
twitter_app_connection = TwitterAppConnection.objects.get(user=request.user, app=app, enabled=True)
except TwitterAppConnection.DoesNotExist:
return bad_request('Invalid `app_id`, not already connected to twitter.')
sub = None
if email:
sub = appstore_review_subscriptions.create_email_subscription(request.user, email)
elif my_email:
sub = appstore_review_subscriptions.create_my_email_subscription(request.user)
elif slack_channel_name:
sub = appstore_review_subscriptions.create_slack_channel_subscription(request.user, slack_channel_name)
elif slack_url:
sub = appstore_review_subscriptions.create_slack_subscription(request.user, slack_url)
elif twitter_app_connection:
sub = appstore_review_subscriptions.create_twitter_subscription_from_connection(twitter_app_connection)
if not sub:
return bad_request('Subscription already exists.')
new_flags = []
if not request.user.flags.has_review_monitor:
new_flags.append('has_review_monitor')
if sub.twitter_connection_id and not request.user.flags.has_review_monitor_tweets:
new_flags.append('has_review_monitor_tweets')
if new_flags:
request.user.set_flags(new_flags)
return api_response({
'subscription': sub.to_dict(),
})
@api_user_view('GET', 'POST')
def subscription_view(request, subscription_id=None):
sub = appstore_review_subscriptions.get_user_subscription_by_encrypted_id(request.user, subscription_id)
if not sub:
return not_found()
if request.method == 'GET':
return api_response({
'subscription': sub.to_dict(),
})
if request.POST.get('filter_good'):
do_filter = request.POST['filter_good'] == '1'
appstore_review_subscriptions.mark_subscription_filtered_good(sub, do_filter)
return api_response({
'subscription': sub.to_dict(),
})
@api_user_view('POST')
def subscription_delete_view(request, subscription_id=None):
sub = appstore_review_subscriptions.get_user_subscription_by_encrypted_id(request.user, subscription_id)
if not sub:
return not_found()
appstore_review_subscriptions.disable_subscription(sub)
return ok_response()
@api_view('POST')
def subscription_unsubscribe_token_view(request):
sub = appstore_review_notify.subscription_from_unsubscribe_token(request.POST.get('token', ''))
if not sub:
return bad_request('Could not find subscription with that `token`.')
appstore_review_subscriptions.disable_subscription(sub)
return ok_response()
|
deer/base_classes/learning_algo.py | jhardy0/deer | 373 | 11099810 | <reponame>jhardy0/deer
"""
This module defines the base class for the learning algorithms.
"""
import numpy as np
class LearningAlgo(object):
""" All the Q-networks, actor-critic networks, etc. should inherit this interface.
Parameters
-----------
environment : object from class Environment
The environment linked to the Q-network
batch_size : int
Number of tuples taken into account for each iteration of gradient descent
"""
def __init__(self, environment, batch_size):
self._environment = environment
self._df = 0.9
self._lr = 0.005
self._input_dimensions = self._environment.inputDimensions()
self._n_actions = self._environment.nActions()
self._batch_size = batch_size
def train(self, states, actions, rewards, nextStates, terminals):
""" This method performs the training step (e.g. using Bellman iteration in a deep Q-network)
for one batch of tuples.
"""
raise NotImplementedError()
def chooseBestAction(self, state):
""" Get the best action for a pseudo-state
"""
raise NotImplementedError()
def qValues(self, state):
""" Get the q value for one pseudo-state
"""
raise NotImplementedError()
def setLearningRate(self, lr):
""" Setting the learning rate
NB: The learning rate has usually to be set in the optimizer, hence this function should
be overridden. Otherwise, the learning rate change is likely not to be taken into account
Parameters
-----------
lr : float
The learning rate that has to bet set
"""
self._lr = lr
def setDiscountFactor(self, df):
""" Setting the discount factor
Parameters
-----------
df : float
The discount factor that has to bet set
"""
if df < 0. or df > 1.:
raise AgentError("The discount factor should be in [0,1]")
self._df = df
def learningRate(self):
""" Getting the learning rate
"""
return self._lr
def discountFactor(self):
""" Getting the discount factor
"""
return self._df
if __name__ == "__main__":
pass
|
Chapter05/thumbnail_limit_sema.py | AlekseiMikhalev/Software-Architecture-with-Python | 103 | 11099817 | # Code Listing #4
"""
Thumbnail producer/consumer - Limiting number of images using a Semaphore.
"""
import threading
import time
import string
import random
import uuid
import urllib.request
from PIL import Image
from queue import Queue
class ThumbnailURL_Generator(threading.Thread):
""" Worker class that generates image URLs """
def __init__(self, queue, sleep_time=1,):
self.sleep_time = sleep_time
self.queue = queue
# A flag for stopping
self.flag = True
# sizes
self._sizes = (240,320,360,480,600,720)
# URL scheme
self.url_template = 'https://dummyimage.com/%s/%s/%s.jpg'
threading.Thread.__init__(self)
def __str__(self):
return 'Producer'
def get_size(self):
return '%dx%d' % (random.choice(self._sizes),
random.choice(self._sizes))
def get_color(self):
return ''.join(random.sample(string.hexdigits[:-6], 3))
def run(self):
""" Main thread function """
while self.flag:
# generate image URLs of random sizes and fg/bg colors
url = self.url_template % (self.get_size(),
self.get_color(),
self.get_color())
# Add to queue
print(self,'Put',url)
self.queue.put(url)
time.sleep(self.sleep_time)
def stop(self):
""" Stop the thread """
self.flag = False
class ThumbnailImageSemaSaver(object):
""" Class which keeps an exact counter of saved images
and restricts the total count using a semaphore """
def __init__(self, limit=10):
self.limit = limit
self.counter = threading.BoundedSemaphore(value=limit)
self.count = 0
# Start time
self.start = time.time()
# Image saving rate
self.rate = 0
def acquire(self):
# Acquire counter, if limit is exhausted, it
# returns False
return self.counter.acquire(blocking=False)
def release(self):
# Release counter, incrementing count
return self.counter.release()
def thumbnail_image(self, url, size=(64,64), format='.png'):
""" Save image thumbnails, given a URL """
im = Image.open(urllib.request.urlopen(url))
# filename is last two parts of URL minus extension + '.format'
pieces = url.split('/')
filename = ''.join((pieces[-2],'_',pieces[-1].split('.')[0],format))
try:
im.thumbnail(size, Image.ANTIALIAS)
im.save(filename)
print('Saved',filename)
self.count += 1
except Exception as e:
print('Error saving URL',url,e)
# Image can't be counted, increment semaphore
self.release()
return True
def save(self, url):
""" Save a URL as thumbnail """
if self.acquire():
self.thumbnail_image(url)
return True
else:
print('Semaphore limit reached, returning False')
return False
class ThumbnailURL_Consumer(threading.Thread):
""" Worker class that consumes URLs and generates thumbnails """
def __init__(self, queue, saver):
self.queue = queue
self.flag = True
self.saver = saver
self.count = 0
# Internal id
self._id = uuid.uuid4().hex
threading.Thread.__init__(self, name='Consumer-'+ self._id)
def __str__(self):
return 'Consumer-' + self._id
def run(self):
""" Main thread function """
while self.flag:
url = self.queue.get()
print(self,'Got',url)
self.count += 1
if not self.saver.save(url):
# Limit reached, break out
print(self, 'Set limit reached, quitting')
break
def stop(self):
""" Stop the thread """
self.flag = False
if __name__ == '__main__':
from queue import Queue
import glob,os
os.system('rm -f *.png')
q = Queue(maxsize=2000)
saver = ThumbnailImageSemaSaver(limit=100)
producers, consumers = [], []
for i in range(3):
t = ThumbnailURL_Generator(q)
producers.append(t)
t.start()
for i in range(5):
t = ThumbnailURL_Consumer(q, saver)
consumers.append(t)
t.start()
for t in consumers:
t.join()
print('Joined', t, flush=True)
# To make sure producers dont block on a full queue
while not q.empty():
item=q.get()
for t in producers:
t.stop()
print('Stopped',t, flush=True)
print('Total number of PNG images',len(glob.glob('*.png')))
|
17-it-generator/tree/extra/test_drawtree.py | SeirousLee/example-code-2e | 990 | 11099823 | from drawtree import tree, render_lines
def test_1_level():
result = list(render_lines(tree(BrokenPipeError)))
expected = [
'BrokenPipeError',
]
assert expected == result
def test_2_levels_1_leaf():
result = list(render_lines(tree(IndentationError)))
expected = [
'IndentationError',
'└── TabError',
]
assert expected == result
def test_3_levels_1_leaf():
class X: pass
class Y(X): pass
class Z(Y): pass
result = list(render_lines(tree(X)))
expected = [
'X',
'└── Y',
' └── Z',
]
assert expected == result
def test_4_levels_1_leaf():
class Level0: pass
class Level1(Level0): pass
class Level2(Level1): pass
class Level3(Level2): pass
result = list(render_lines(tree(Level0)))
expected = [
'Level0',
'└── Level1',
' └── Level2',
' └── Level3',
]
assert expected == result
def test_2_levels_2_leaves():
class Branch: pass
class Leaf1(Branch): pass
class Leaf2(Branch): pass
result = list(render_lines(tree(Branch)))
expected = [
'Branch',
'├── Leaf1',
'└── Leaf2',
]
assert expected == result
def test_3_levels_2_leaves_dedent():
class A: pass
class B(A): pass
class C(B): pass
class D(A): pass
class E(D): pass
result = list(render_lines(tree(A)))
expected = [
'A',
'├── B',
'│ └── C',
'└── D',
' └── E',
]
assert expected == result
def test_4_levels_4_leaves_dedent():
class A: pass
class B1(A): pass
class C1(B1): pass
class D1(C1): pass
class D2(C1): pass
class C2(B1): pass
class B2(A): pass
expected = [
'A',
'├── B1',
'│ ├── C1',
'│ │ ├── D1',
'│ │ └── D2',
'│ └── C2',
'└── B2',
]
result = list(render_lines(tree(A)))
assert expected == result
|
cpmpy/post_office_problem2.py | tias/hakank | 279 | 11099854 | """
Post office problem in cpmpy.
Problem statement:
http://www-128.ibm.com/developerworks/linux/library/l-glpk2/
From Winston 'Operations Research: Applications and Algorithms':
'''
A post office requires a different number of full-time employees working
on different days of the week [summarized below]. Union rules state that
each full-time employee must work for 5 consecutive days and then receive
two days off. For example, an employee who works on Monday to Friday
must be off on Saturday and Sunday. The post office wants to meet its
daily requirements using only full-time employees. Minimize the number
of employees that must be hired.
To summarize the important information about the problem:
* Every full-time worker works for 5 consecutive days and takes 2 days off
* Day 1 (Monday): 17 workers needed
* Day 2 : 13 workers needed
* Day 3 : 15 workers needed
* Day 4 : 19 workers needed
* Day 5 : 14 workers needed
* Day 6 : 16 workers needed
* Day 7 (Sunday) : 11 workers needed
The post office needs to minimize the number of employees it needs
to hire to meet its demand.
'''
Model created by <NAME>, <EMAIL>
See also my cpmpy page: http://www.hakank.org/cpmpy/
"""
import sys
import numpy as np
from cpmpy import *
from cpmpy.solvers import *
from cpmpy_hakank import *
def post_office_problem2():
#
# data
#
# days 0..6, monday 0
n = 7
days = list(range(n))
need = [17, 13, 15, 19, 14, 16, 11]
# Total cost for the 5 day schedule.
# Base cost per day is 100.
# Working saturday is 100 extra
# Working sunday is 200 extra.
cost = [500, 600, 800, 800, 800, 800, 700]
#
# variables
#
# Number of workers starting at day i
x = intvar(0,100,shape=n,name="x")
total_cost = intvar(0, 20000, name="total_cost")
num_workers = intvar(0, 100, name="num_workers")
model = Model(minimize=total_cost)
#
# constraints
#
model += [total_cost == sum(x*cost)]
model += [num_workers == sum(x)]
for i in days:
model += [sum([x[j] for j in days
if j != (i + 5) % n and j != (i + 6) % n])
>= need[i]]
ss = CPM_ortools(model)
num_solutions = 0
if ss.solve():
num_solutions += 1
print("num_workers:", num_workers.value())
print("total_cost:", total_cost.value())
print("x:", x.value())
post_office_problem2()
|
tests/daemon/unit/api/endpoints/test_common.py | Karnak123/jina | 15,179 | 11099875 | <reponame>Karnak123/jina<filename>tests/daemon/unit/api/endpoints/test_common.py
import os
import time
import pytest
from daemon.dockerize import Dockerizer
from daemon.models.containers import ContainerItem
cur_dir = os.path.dirname(os.path.abspath(__file__))
deps = ['mwu_encoder.py', 'mwu_encoder.yml']
@pytest.fixture(scope='module', autouse=True)
def workspace():
from tests.conftest import _create_workspace_directly, _clean_up_workspace
image_id, network_id, workspace_id, workspace_store = _create_workspace_directly(
cur_dir
)
yield workspace_id
_clean_up_workspace(image_id, network_id, workspace_id, workspace_store)
@pytest.mark.parametrize('api', ['/peas', '/pods', '/flows'])
def test_args(api, fastapi_client):
response = fastapi_client.get(f'{api}/arguments')
assert response.status_code == 200
assert response.json()
@pytest.mark.parametrize('api', ['/peas', '/pods', '/flows', '/workspaces'])
def test_status(api, fastapi_client):
response = fastapi_client.get(f'{api}')
assert response.status_code == 200
assert response.json()
@pytest.mark.parametrize('api', ['/peas', '/pods', '/flows'])
def test_delete(api, fastapi_client):
response = fastapi_client.delete(f'{api}')
assert response.status_code == 200
def _validate_response(response, payload, id, workspace_id):
assert response.status_code == 200
get_response = response.json()
item = ContainerItem(**get_response)
assert item.workspace_id == workspace_id
assert item.metadata.container_name == id
if 'json' in payload:
assert item.arguments.object['arguments']['name'] == payload['json']['name']
@pytest.mark.parametrize(
'api, payload',
[
(
'/peas',
{
'json': {'name': 'my_pea'},
},
),
(
'/pods',
{
'json': {'name': 'my_pod'},
},
),
],
)
def test_add_same_del_all(api, payload, fastapi_client, workspace):
_existing_containers = Dockerizer.containers
for _ in range(3):
# this test the random default_factory
payload['params'] = {'workspace_id': workspace}
post_response = fastapi_client.post(api, **payload)
assert post_response.status_code == 201
obj_id = post_response.json()
assert obj_id in Dockerizer.containers
r = fastapi_client.get(f'{api}/{obj_id}')
_validate_response(r, payload, obj_id, workspace)
response = fastapi_client.get(api)
assert response.status_code == 200
num_add = response.json()['num_add']
response = fastapi_client.delete(api)
assert response.status_code == 200
response = fastapi_client.get(api)
assert response.status_code == 200
assert response.json()['num_del'] == num_add
time.sleep(1)
assert Dockerizer.containers == _existing_containers
@pytest.mark.parametrize(
'api, payload',
[
(
'/peas',
{
'json': {'name': 'my_pea'},
},
),
(
'/pods',
{
'json': {'name': 'my_pod'},
},
),
(
'/flows',
{'params': {'filename': 'good_flow.yml'}},
),
(
'/flows',
{'params': {'filename': 'good_flow_jtype.yml'}},
),
],
)
def test_add_success(api, payload, fastapi_client, workspace):
if 'params' not in payload:
payload['params'] = {'workspace_id': workspace}
else:
payload['params'].update({'workspace_id': workspace})
post_response = fastapi_client.post(api, **payload)
assert post_response.status_code == 201
obj_id = post_response.json()
assert obj_id in Dockerizer.containers
r = fastapi_client.get(f'{api}/{obj_id}')
_validate_response(r, payload, obj_id, workspace)
response = fastapi_client.get(api)
assert response.status_code == 200
response = fastapi_client.get(f'{api}/{obj_id}')
assert response.status_code == 200
assert 'time_created' in response.json()
response = fastapi_client.delete(f'{api}/{obj_id}')
assert response.status_code == 200
response = fastapi_client.get(api)
assert response.status_code == 200
@pytest.mark.parametrize(
'api, payload',
[
('/peas', {'json': {'name': 'my_pea', 'uses': 'BAD'}}),
('/pods', {'json': {'name': 'my_pod', 'uses': 'BAD'}}),
(
'/flows',
{'params': {'filename': 'bad_flow.yml'}},
),
],
)
def test_add_fail(api, payload, fastapi_client, workspace):
if 'params' not in payload:
payload['params'] = {'workspace_id': workspace}
else:
payload['params'].update({'workspace_id': workspace})
response = fastapi_client.get(api)
assert response.status_code == 200
old_add = response.json()['num_add']
response = fastapi_client.post(api, **payload)
assert response.status_code != 201
if response.status_code == 400:
for k in ('body', 'detail'):
assert k in response.json()
response = fastapi_client.get(api)
assert response.status_code == 200
assert response.json()['num_add'] == old_add
|
2019/quals/hardware-flagrom/solution/secondary/exploit.py | iicarus-bit/google-ctf | 2,757 | 11099903 | #!/usr/bin/python
# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import subprocess
import socket
import hashlib
import sys
def recvuntil(sock, txt):
d = ""
while d.find(txt) == -1:
try:
dnow = sock.recv(1)
if len(dnow) == 0:
return ("DISCONNECTED", d)
except socket.timeout:
return ("TIMEOUT", d)
except socket.error as msg:
return ("ERROR", d)
d += dnow
return ("OK", d)
def recvall(sock, n):
d = ""
while len(d) != n:
try:
dnow = sock.recv(n - len(d))
if len(dnow) == 0:
return ("DISCONNECTED", d)
except socket.timeout:
return ("TIMEOUT", d)
except socket.error as msg:
return ("ERROR", d)
d += dnow
return ("OK", d)
# Proxy object for sockets.
class gsocket(object):
def __init__(self, *p):
self._sock = socket.socket(*p)
def __getattr__(self, name):
return getattr(self._sock, name)
def recvall(self, n):
err, ret = recvall(self._sock, n)
if err != "OK":
return False
return ret
def recvuntil(self, txt):
err, ret = recvuntil(self._sock, txt)
if err != "OK":
return False
return ret
# Proxy object for pipes
class psocket(object):
def __init__(self, pin, pout):
self._pin = pin
self._pout = pout
def __getattr__(self, name):
print "__getattr__:", name
return None
def recv(self, n):
return self._pin.read(n)
def send(self, n):
return self._pout.write(n)
def sendall(self, n):
return self.send(n)
def recvall(self, n):
err, ret = recvall(self, n)
if err != "OK":
return False
return ret
def recvuntil(self, txt):
err, ret = recvuntil(self, txt)
if err != "OK":
return False
return ret
def prepare_payload():
print "[ 8051 ] Compiling payload..."
subprocess.check_call(["make", "-B"])
with open("exploit.8051", "rb") as f:
return f.read()
def test_local(payload):
p = subprocess.Popen(["./flagrom"], cwd='..', stdin=subprocess.PIPE, stdout=subprocess.PIPE)
send_payload(psocket(p.stdout, p.stdin), payload)
stdoutdata, stderrdata = p.communicate()
print stdoutdata
print stderrdata
def get_pow(pow):
sys.stdout.write("[ PoW ] md5('flagrom-???') starts with '%s'... " % pow)
sys.stdout.flush()
pow = pow.decode("hex")
for i in xrange(0xf000000):
x = "flagrom-%i" % i
if hashlib.md5(x).digest().startswith(pow):
print x
return x
print "NOT FOUND"
def send_payload(s, payload):
pow_line = s.recvuntil("?\n").strip()
print "[ Recv ]", pow_line
pow = pow_line.split(" ")[-1].replace("?", "")
response = get_pow(pow)
s.sendall("%s\n" % response)
length_line = s.recvuntil("payload?\n").strip()
print "[ Recv ]", length_line
print "[ Len ]", len(payload)
s.sendall("%i\n" % len(payload))
print "[ Send ] Sending payload...",
sys.stdout.flush()
s.sendall(payload)
print "Sent!"
def test_remote(payload, addr):
host, port = addr.split(':')
s = gsocket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, int(port)))
send_payload(s, payload)
while True:
ret = s.recv(1)
if not ret:
break
sys.stdout.write(ret)
s.close()
if len(sys.argv) == 1:
print "[ ] Testing using stdin/out redirection!"
print "[ ] (if you want to run this exploit remotly: ./exploit.py ip:port)"
test_local(prepare_payload())
else:
print "[ ] Testing remotly!"
test_remote(prepare_payload(), sys.argv[1])
|
tests/fuzzing/test_build_graphql_schema_from_sdl_fuzz.py | matt-koevort/tartiflette | 530 | 11099932 | # import sys
#
# import afl
# from tartiflette.sdl.builder import build_graphql_schema_from_sdl
# from tartiflette.sdl.schema import GraphQLSchema
# We use American Fuzzy Loop for this.
# TODO: Do the same with libgraphqlparser (needs good security :) )
# Commented for the moment, so pytest won't complain.
# afl.init()
#
# try:
# build_graphql_schema_from_sdl(sys.stdin.read(),
# schema=GraphQLSchema())
# except ValueError:
# pass
|
aiochan/test/test_buffer.py | agentOfChaos/aiochan | 128 | 11099933 | <filename>aiochan/test/test_buffer.py
from aiochan.buffers import *
def test_fixed_buffer():
buffer = FixedLengthBuffer(3)
assert buffer.can_add
assert not buffer.can_take
buffer.add(1)
buffer.add(2)
assert buffer.can_add
assert buffer.can_take
buffer.add(3)
assert not buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
assert buffer.can_add
assert buffer.can_take
assert buffer.take() == 2
assert buffer.take() == 3
assert buffer.can_add
assert not buffer.can_take
assert buffer.__repr__()
def test_dropping_buffer():
buffer = DroppingBuffer(2)
assert buffer.can_add
assert not buffer.can_take
buffer.add(1)
buffer.add(2)
assert buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
buffer.add(3)
buffer.add(4)
assert buffer.take() == 2
assert buffer.take() == 3
assert buffer.can_add
assert not buffer.can_take
assert buffer.__repr__()
def test_sliding_buffer():
buffer = SlidingBuffer(2)
assert buffer.can_add
assert not buffer.can_take
buffer.add(1)
buffer.add(2)
assert buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
buffer.add(3)
buffer.add(4)
assert buffer.take() == 3
assert buffer.take() == 4
assert buffer.can_add
assert not buffer.can_take
assert buffer.__repr__()
def test_promise_buffer():
buffer = PromiseBuffer(None)
assert buffer.can_add
assert not buffer.can_take
buffer.add(1)
assert buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
buffer.add(2)
assert buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
assert buffer.__repr__()
def test_it_buffer():
buffer = IterBuffer(())
assert not buffer.can_add
assert not buffer.can_take
buffer = IterBuffer(range(2))
assert not buffer.can_add
assert buffer.can_take
assert buffer.take() == 0
assert not buffer.can_add
assert buffer.can_take
assert buffer.take() == 1
assert not buffer.can_add
assert not buffer.can_take
|
libreasr/lib/layers/mish.py | johnpaulbin/LibreASR | 680 | 11099961 | import torch
import torch.nn as nn
import torch.nn.functional as F
def _mish_fwd(x):
return x.mul(torch.tanh(F.softplus(x)))
def _mish_bwd(x, grad_output):
x_sigmoid = torch.sigmoid(x)
x_tanh_sp = F.softplus(x).tanh()
return grad_output.mul(x_tanh_sp + x * x_sigmoid * (1 - x_tanh_sp * x_tanh_sp))
class MishAutoFn(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
ctx.save_for_backward(x)
return _mish_fwd(x)
@staticmethod
def backward(ctx, grad_output):
x = ctx.saved_variables[0]
return _mish_bwd(x, grad_output)
class _Mish(nn.Module):
def forward(self, x):
return MishAutoFn.apply(x)
try:
from fastai2.layers import Mish
Mish = Mish
print("Using Mish activation from fastai2.")
except:
Mish = _Mish
print("Using Mish activation from lib.layers.")
|
tests/test_slots_and_tokens.py | aalba6675/python-pkcs11 | 114 | 11099969 | """
PKCS#11 Slots and Tokens
"""
import unittest
import pkcs11
from . import LIB, TOKEN, Only, Not
class SlotsAndTokensTests(unittest.TestCase):
def test_double_initialise(self):
self.assertIsNotNone(pkcs11.lib(LIB))
self.assertIsNotNone(pkcs11.lib(LIB))
def test_double_initialise_different_libs(self):
self.assertIsNotNone(pkcs11.lib(LIB))
with self.assertRaises(pkcs11.AlreadyInitialized):
pkcs11.lib('somethingelse.so')
@Only.softhsm2
def test_get_slots(self):
lib = pkcs11.lib(LIB)
slots = lib.get_slots()
self.assertEqual(len(slots), 2)
slot1, slot2 = slots
self.assertIsInstance(slot1, pkcs11.Slot)
self.assertEqual(slot1.flags, pkcs11.SlotFlag.TOKEN_PRESENT)
def test_get_mechanisms(self):
lib = pkcs11.lib(LIB)
slot, *_ = lib.get_slots()
mechanisms = slot.get_mechanisms()
self.assertIn(pkcs11.Mechanism.RSA_PKCS, mechanisms)
def test_get_mechanism_info(self):
lib = pkcs11.lib(LIB)
slot, *_ = lib.get_slots()
info = slot.get_mechanism_info(pkcs11.Mechanism.RSA_PKCS_OAEP)
self.assertIsInstance(info, pkcs11.MechanismInfo)
@Not.nfast # EC not supported
@Not.opencryptoki
def test_get_mechanism_info_ec(self):
lib = pkcs11.lib(LIB)
slot, *_ = lib.get_slots()
info = slot.get_mechanism_info(pkcs11.Mechanism.EC_KEY_PAIR_GEN)
self.assertIsInstance(info, pkcs11.MechanismInfo)
self.assertIn(pkcs11.MechanismFlag.EC_NAMEDCURVE, info.flags)
@Only.softhsm2
def test_get_tokens(self):
lib = pkcs11.lib(LIB)
tokens = lib.get_tokens(token_flags=pkcs11.TokenFlag.RNG)
self.assertEqual(len(list(tokens)), 2)
tokens = lib.get_tokens(token_label=TOKEN)
self.assertEqual(len(list(tokens)), 1)
@Only.softhsm2
def test_get_token(self):
lib = pkcs11.lib(LIB)
slot, *_ = lib.get_slots()
token = slot.get_token()
self.assertIsInstance(token, pkcs11.Token)
self.assertEqual(token.label, TOKEN)
self.assertIn(pkcs11.TokenFlag.TOKEN_INITIALIZED, token.flags)
self.assertIn(pkcs11.TokenFlag.LOGIN_REQUIRED, token.flags)
|
cartoframes/viz/style.py | CartoDB/cartoframes | 236 | 11099980 | from . import defaults
from ..utils.utils import merge_dicts, text_match
class Style:
def __init__(self, data=None, value=None,
default_legend=None, default_widget=None,
default_popup_hover=None, default_popup_click=None):
self._style = self._init_style(data=data)
self._value = value
self._default_legend = default_legend
self._default_widget = default_widget
self._default_popup_hover = default_popup_hover
self._default_popup_click = default_popup_click
def _init_style(self, data):
if data is None:
return defaults.STYLE
elif isinstance(data, (str, dict)):
return data
else:
raise ValueError('`style` must be a dictionary')
@property
def value(self):
return self._value
@property
def default_legend(self):
return self._default_legend
@property
def default_widget(self):
return self._default_widget
@property
def default_popup_hover(self):
return self._default_popup_hover
@property
def default_popup_click(self):
return self._default_popup_click
def compute_viz(self, geom_type, variables={}):
style = self._style
default_style = defaults.STYLE[geom_type]
if isinstance(style, str):
# Only for testing purposes
return self._parse_style_str(style, default_style, variables)
elif isinstance(style, dict):
if geom_type in style:
style = style.get(geom_type)
return self._parse_style_dict(style, default_style, variables)
else:
raise ValueError('`style` must be a dictionary')
def _parse_style_dict(self, style, default_style, ext_vars):
variables = merge_dicts(style.get('vars', {}), ext_vars)
properties = merge_dicts(default_style, style)
serialized_variables = self._serialize_variables(variables)
serialized_properties = self._serialize_properties(properties)
return serialized_variables + serialized_properties
def _parse_style_str(self, style, default_style, ext_vars):
variables = ext_vars
default_properties = self._prune_defaults(default_style, style)
serialized_variables = self._serialize_variables(variables)
serialized_default_properties = self._serialize_properties(default_properties)
return serialized_variables + serialized_default_properties + style
def _serialize_variables(self, variables={}):
output = ''
for var in sorted(variables):
output += '@{name}: {value}\n'.format(
name=var,
value=variables.get(var)
)
return output
def _serialize_properties(self, properties={}):
output = ''
for prop in sorted(properties):
if prop == 'vars':
continue
output += '{name}: {value}\n'.format(
name=prop,
value=properties.get(prop)
)
return output
def _prune_defaults(self, default_style, style):
output = default_style.copy()
if 'color' in output and text_match(r'color\s*:', style):
del output['color']
if 'width' in output and text_match(r'width\s*:', style):
del output['width']
if 'strokeColor' in output and text_match(r'strokeColor\s*:', style):
del output['strokeColor']
if 'strokeWidth' in output and text_match(r'strokeWidth\s*:', style):
del output['strokeWidth']
return output
|
tests/conftest.py | pystitch/stitch | 468 | 11100017 | import pytest
def pytest_addoption(parser):
parser.addoption("--run-slow", action="store_true",
help="run slow tests")
def pytest_runtest_setup(item):
if 'slow' in item.keywords and not item.config.getoption("--run-slow"):
pytest.skip("need --run-slow option to run")
|
venv/lib/python2.7/site-packages/gevent/util.py | egromero/chat_app_flask | 2,557 | 11100019 | <gh_stars>1000+
# Copyright (c) 2009 <NAME>. See LICENSE for details.
"""
Low-level utilities.
"""
from __future__ import absolute_import
import functools
__all__ = ['wrap_errors']
class wrap_errors(object):
"""
Helper to make function return an exception, rather than raise it.
Because every exception that is unhandled by greenlet will be logged,
it is desirable to prevent non-error exceptions from leaving a greenlet.
This can done with a simple ``try/except`` construct::
def wrapped_func(*args, **kwargs):
try:
return func(*args, **kwargs)
except (TypeError, ValueError, AttributeError) as ex:
return ex
This class provides a shortcut to write that in one line::
wrapped_func = wrap_errors((TypeError, ValueError, AttributeError), func)
It also preserves ``__str__`` and ``__repr__`` of the original function.
"""
# QQQ could also support using wrap_errors as a decorator
def __init__(self, errors, func):
"""
Calling this makes a new function from *func*, such that it catches *errors* (an
:exc:`BaseException` subclass, or a tuple of :exc:`BaseException` subclasses) and
return it as a value.
"""
self.__errors = errors
self.__func = func
# Set __doc__, __wrapped__, etc, especially useful on Python 3.
functools.update_wrapper(self, func)
def __call__(self, *args, **kwargs):
func = self.__func
try:
return func(*args, **kwargs)
except self.__errors as ex:
return ex
def __str__(self):
return str(self.__func)
def __repr__(self):
return repr(self.__func)
def __getattr__(self, name):
return getattr(self.__func, name)
|
rapidsms/messages/tests.py | catalpainternational/rapidsms | 330 | 11100031 | <reponame>catalpainternational/rapidsms
from rapidsms.messages.base import MessageBase
from rapidsms.messages.incoming import IncomingMessage
from rapidsms.messages.outgoing import OutgoingMessage
from rapidsms.tests.harness import RapidTest
class MessagesTest(RapidTest):
disable_phases = True
def test_message_id(self):
"""All message objects should have IDs."""
connections = [self.create_connection()]
msg = MessageBase(text="test", connections=connections)
self.assertIsNotNone(msg.id)
msg = IncomingMessage(text="test", connections=connections)
self.assertIsNotNone(msg.id)
msg = OutgoingMessage(text="test", connections=connections)
self.assertIsNotNone(msg.id)
def test_saved_message_fields(self):
"""Extra data should be attached to IncomingMessage."""
connection = self.create_connection()
fields = {'extra-field': 'extra-value'}
message = IncomingMessage(connection, 'test incoming message',
fields=fields)
self.assertIn('extra-field', message.fields)
self.assertEqual(message.fields['extra-field'], fields['extra-field'])
def test_outgoing_message_link(self):
"""Extra data should be attached to response (OutgoingMessage)."""
connection = self.create_connection()
fields = {'extra-field': 'extra-value'}
message = IncomingMessage(connection, 'test incoming message',
fields=fields)
response = message.respond('response')
self.assertEqual(message, response['in_response_to'])
self.assertIn('extra-field', response['in_response_to'].fields)
def test_outgoing_message_send(self):
"""OutgoingMessage.send should use send() API correctly"""
message = self.create_outgoing_message()
message.send()
self.assertEqual(self.outbound[0].text, message.text)
def test_response_context(self):
"""
InboundMessage responses should contain proper context for
creating OutboundMessages by the router.
"""
inbound_message = self.create_incoming_message()
inbound_message.respond('test1')
inbound_message.respond('test2')
self.assertEqual(2, len(inbound_message.responses))
response1 = inbound_message.responses[0]
self.assertEqual("test1", response1['text'])
self.assertEqual(inbound_message.connections, response1['connections'])
# reply_to should reference original message
self.assertEqual(inbound_message, response1['in_response_to'])
|
src/python/twitter/common/app/inspection.py | zhouyijiaren/commons | 1,143 | 11100064 | # ==================================================================================================
# Copyright 2011 Twitter, Inc.
# --------------------------------------------------------------------------------------------------
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this work except in compliance with the License.
# You may obtain a copy of the License in the LICENSE file, or at:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==================================================================================================
from __future__ import print_function
import inspect
import os
import sys
class Inspection(object):
class InternalError(Exception): pass
# TODO(wickman)
# Remove all calls to inspect.stack(). This is just bad. Port everything over
# to iterating from currentframe => outer frames.
@staticmethod
def find_main_from_caller():
last_frame = inspect.currentframe()
while True:
inspect_frame = last_frame.f_back
if not inspect_frame:
break
if 'main' in inspect_frame.f_locals:
return inspect_frame.f_locals['main']
last_frame = inspect_frame
raise Inspection.InternalError("Unable to detect main from the stack!")
@staticmethod
def print_stack_locals(out=sys.stderr):
stack = inspect.stack()[1:]
for fr_n in range(len(stack)):
print('--- frame %s ---\n' % fr_n, file=out)
for key in stack[fr_n][0].f_locals:
print(' %s => %s' % (key, stack[fr_n][0].f_locals[key]), file=out)
@staticmethod
def find_main_module():
stack = inspect.stack()[1:]
for fr_n in range(len(stack)):
if 'main' in stack[fr_n][0].f_locals:
return stack[fr_n][0].f_locals['__name__']
return None
@staticmethod
def get_main_locals():
stack = inspect.stack()[1:]
for fr_n in range(len(stack)):
if '__name__' in stack[fr_n][0].f_locals and (
stack[fr_n][0].f_locals['__name__'] == '__main__'):
return stack[fr_n][0].f_locals
return {}
@staticmethod
def find_calling_module():
last_frame = inspect.currentframe()
while True:
inspect_frame = last_frame.f_back
if not inspect_frame:
break
if '__name__' in inspect_frame.f_locals:
return inspect_frame.f_locals['__name__']
last_frame = inspect_frame
raise Inspection.InternalError("Unable to interpret stack frame!")
@staticmethod
def find_application_name():
__entry_point__ = None
locals = Inspection.get_main_locals()
if '__file__' in locals and locals['__file__'] is not None:
__entry_point__ = locals['__file__']
elif '__loader__' in locals:
from zipimport import zipimporter
from pkgutil import ImpLoader
# TODO(wickman) The monkeypatched zipimporter should probably not be a function
# but instead a properly delegating proxy.
if hasattr(locals['__loader__'], 'archive'):
# assuming it ends in .zip or .egg, it may be of package format, so
# foo-version-py2.6-arch.egg, so split off anything after '-'.
__entry_point__ = os.path.basename(locals['__loader__'].archive)
__entry_point__ = __entry_point__.split('-')[0].split('.')[0]
elif isinstance(locals['__loader__'], ImpLoader):
__entry_point__ = locals['__loader__'].get_filename()
else:
__entry_point__ = '__interpreter__'
app_name = os.path.basename(__entry_point__)
return app_name.split('.')[0]
|
uq360/utils/generate_1D_regression_data.py | Sclare87/UQ360 | 148 | 11100112 | import matplotlib.pyplot as plt
import numpy as np
import numpy.random as npr
import torch as torch
def make_data_gap(seed, data_count=100):
import GPy
npr.seed(0)
x = np.hstack([np.linspace(-5, -2, int(data_count/2)), np.linspace(2, 5, int(data_count/2))])
x = x[:, np.newaxis]
k = GPy.kern.RBF(input_dim=1, variance=1., lengthscale=1.)
K = k.K(x)
L = np.linalg.cholesky(K + 1e-5 * np.eye(data_count))
# draw a noise free random function from a GP
eps = np.random.randn(data_count)
f = L @ eps
# use a homoskedastic Gaussian noise model N(f(x)_i, \sigma^2). \sigma^2 = 0.1
eps_noise = np.sqrt(0.1) * np.random.randn(data_count)
y = f + eps_noise
y = y[:, np.newaxis]
plt.plot(x, f, 'ko', ms=2)
plt.plot(x, y, 'ro')
plt.title("GP generated Data")
plt.pause(1)
return torch.FloatTensor(x), torch.FloatTensor(y), torch.FloatTensor(x), torch.FloatTensor(y)
def make_data_sine(seed, data_count=450):
# fix the random seed
np.random.seed(seed)
noise_var = 0.1
X = np.linspace(-4, 4, data_count)
y = 1*np.sin(X) + np.sqrt(noise_var)*npr.randn(data_count)
train_count = int (0.2 * data_count)
idx = npr.permutation(range(data_count))
X_train = X[idx[:train_count], np.newaxis ]
X_test = X[ idx[train_count:], np.newaxis ]
y_train = y[ idx[:train_count] ]
y_test = y[ idx[train_count:] ]
mu = np.mean(X_train, 0)
std = np.std(X_train, 0)
X_train = (X_train - mu) / std
X_test = (X_test - mu) / std
mu = np.mean(y_train, 0)
std = np.std(y_train, 0)
# mu = 0
# std = 1
y_train = (y_train - mu) / std
y_test = (y_test -mu) / std
train_stats = dict()
train_stats['mu'] = torch.FloatTensor([mu])
train_stats['sigma'] = torch.FloatTensor([std])
return torch.FloatTensor(X_train), torch.FloatTensor(y_train), torch.FloatTensor(X_test), torch.FloatTensor(y_test),\
train_stats |
30 Days of Code/Python/20 - Day 19 - Interfaces.py | srgeyK87/Hacker-Rank-30-days-challlenge | 275 | 11100150 | <reponame>srgeyK87/Hacker-Rank-30-days-challlenge
# ========================
# Information
# ========================
# Direct Link: https://www.hackerrank.com/challenges/30-interfaces/problem
# Difficulty: Easy
# Max Score: 30
# Language: Python
# ========================
# Solution
# ========================
class AdvancedArithmetic(object):
def divisorSum(n):
raise NotImplementedError
class Calculator(AdvancedArithmetic):
def divisorSum(self, n):
sum = 0
for i in range(1, n//2 + 1):
if n % i == 0:
sum += i
return sum + n
n = int(input())
my_calculator = Calculator()
s = my_calculator.divisorSum(n)
print("I implemented: " + type(my_calculator).__bases__[0].__name__)
print(s)
|
ochre/rmgarbage.py | KBNLresearch/ochre | 113 | 11100184 | <reponame>KBNLresearch/ochre<filename>ochre/rmgarbage.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Implementation of rmgarbage.
As described in the paper:
<NAME>., <NAME>., <NAME>. and <NAME>., 2001. Automatic
removal of "garbage strings" in OCR text: An implementation. In The 5th
World Multi-Conference on Systemics, Cybernetics and Informatics.
"""
import click
import codecs
import os
import pandas as pd
from string import punctuation
from nlppln.utils import create_dirs, out_file_name
def get_rmgarbage_errors(word):
errors = []
if rmgarbage_long(word):
errors.append('L')
if rmgarbage_alphanumeric(word):
errors.append('A')
if rmgarbage_row(word):
errors.append('R')
if rmgarbage_vowels(word):
errors.append('V')
if rmgarbage_punctuation(word):
errors.append('P')
if rmgarbage_case(word):
errors.append('C')
return errors
def rmgarbage_long(string, threshold=40):
if len(string) > threshold:
return True
return False
def rmgarbage_alphanumeric(string):
alphanumeric_chars = sum(c.isalnum() for c in string)
if len(string) > 2 and (alphanumeric_chars+0.0)/len(string) < 0.5:
return True
return False
def rmgarbage_row(string, rep=4):
for c in string:
if c.isalnum():
if c * rep in string:
return True
return False
def rmgarbage_vowels(string):
string = string.lower()
if len(string) > 2 and string.isalpha():
vowels = sum(c in u'aáâàåãäeéèëêuúûùüiíîìïoóôòøõö' for c in string)
consonants = len(string) - vowels
low = min(vowels, consonants)
high = max(vowels, consonants)
if low/(high+0.0) <= 0.1:
return True
return False
def rmgarbage_punctuation(string):
string = string[1:len(string)-1]
punctuation_marks = set()
for c in string:
if c in punctuation:
punctuation_marks.add(c)
if len(punctuation_marks) > 1:
return True
return False
def rmgarbage_case(string):
if string[0].islower() and string[len(string)-1].islower():
for c in string:
if c.isupper():
return True
return False
@click.command()
@click.argument('in_file', type=click.File(encoding='utf-8'))
@click.option('--out_dir', '-o', default=os.getcwd(), type=click.Path())
def rmgarbage(in_file, out_dir):
create_dirs(out_dir)
text = in_file.read()
words = text.split()
doc_id = os.path.basename(in_file.name).split('.')[0]
result = []
removed = []
for word in words:
errors = get_rmgarbage_errors(word)
if len(errors) == 0:
result.append(word)
else:
removed.append({'word': word,
'errors': u''.join(errors),
'doc_id': doc_id})
out_file = out_file_name(out_dir, in_file.name)
with codecs.open(out_file, 'wb', encoding='utf-8') as f:
f.write(u' '.join(result))
metadata_out = pd.DataFrame(removed)
fname = '{}-rmgarbage-metadata.csv'.format(doc_id)
out_file = out_file_name(out_dir, fname)
metadata_out.to_csv(out_file, encoding='utf-8')
if __name__ == '__main__':
rmgarbage()
|
core/common.py | madflojo/automon | 414 | 11100187 | '''
Automatron: Module for common tasks
'''
import argparse
import os
import sys
import yaml
import signal
def get_opts(description):
''' Parse command line arguments '''
parser = argparse.ArgumentParser(description=description)
parser.add_argument("-c", "--config", dest="config", help="specify a configuration file")
args = parser.parse_args()
if args.config is None:
parser.print_help()
return args.config
def load_config(config):
''' Load config file into a dictionary '''
if os.path.isfile(config):
with open(config, "r") as fh:
config = yaml.safe_load(fh)
return config
return None
def get_config(description=None):
''' Get configuration file from cmdline and get yaml from file '''
config = get_opts(description)
if config is None:
sys.exit(1)
else:
config = load_config(config)
if config is None:
return False
else:
return config
def kill_threads(threads):
''' Used to kill of multi process threads '''
for thread in threads:
try:
os.kill(thread.pid, signal.SIGTERM)
except OSError:
pass
if __name__ == '__main__':
pass
|
src/radish/parser/core.py | bingyujin/radish | 182 | 11100191 | <reponame>bingyujin/radish
"""
radish
~~~~~~
The root from red to green. BDD tooling for Python.
:copyright: (c) 2019 by <NAME> <<EMAIL>>
:license: MIT, see LICENSE for more details.
"""
import json
import re
from pathlib import Path
from lark import Lark, UnexpectedInput
from radish.models import PreconditionTag
from radish.parser.errors import (
RadishLanguageNotFound,
RadishMisplacedBackground,
RadishMissingFeatureShortDescription,
RadishMissingRuleShortDescription,
RadishMissingScenarioShortDescription,
RadishMultipleBackgrounds,
RadishPreconditionScenarioDoesNotExist,
RadishPreconditionScenarioRecursion,
RadishScenarioLoopInvalidIterationsValue,
RadishScenarioLoopMissingIterations,
RadishScenarioOutlineExamplesInconsistentCellCount,
RadishScenarioOutlineExamplesMissingClosingVBar,
RadishScenarioOutlineExamplesMissingOpeningVBar,
RadishScenarioOutlineWithoutExamples,
RadishStepDataTableMissingClosingVBar,
RadishStepDocStringNotClosed,
RadishStepDoesNotStartWithKeyword,
)
from radish.parser.transformer import RadishGherkinTransformer, Transformer
class LanguageSpec:
"""Represents a gherkin language specification"""
def __init__(self, code, keywords):
self.code = code
self.keywords = keywords
self.first_level_step_keywords = {
keywords["Given"],
keywords["When"],
keywords["Then"],
}
def __str__(self):
return self.code
def __call__(self, terminal):
try:
terminal.pattern.value = self.keywords[terminal.pattern.value]
except KeyError:
pass
class FeatureFileParser:
"""Radish Feature File Parser responsible to parse a single Feature File"""
def __init__(
self,
grammerfile: Path = None,
ast_transformer: Transformer = RadishGherkinTransformer,
resolve_preconditions: bool = True,
) -> None:
if grammerfile is None:
grammerfile = Path(__file__).parent / "grammer.g"
self.grammerfile = grammerfile
self.resolve_preconditions = resolve_preconditions
if ast_transformer is not None:
self._transformer = ast_transformer()
else:
self._transformer = None
self._current_feature_id = 1
self._parsers = {}
def _get_parser(self, language_spec):
"""Get a parser and lazy create it if necessary"""
try:
return self._parsers[language_spec.code]
except KeyError:
parser = Lark.open(
str(self.grammerfile),
parser="lalr",
transformer=self._transformer,
edit_terminals=language_spec,
)
self._parsers[language_spec.code] = parser
return parser
def parse(self, featurefile: Path):
"""Parse the given Feature File"""
ast = self.parse_file(featurefile, self._current_feature_id)
self._current_feature_id += 1
if self.resolve_preconditions:
self._resolve_preconditions(featurefile.parent, ast, {ast.path: ast})
return ast
def parse_file(self, featurefile: Path, feature_id: int = 0):
"""Parse the given Feature File using the parser"""
with open(str(featurefile), "r", encoding="utf-8") as featurefile_f:
contents = featurefile_f.read()
return self.parse_contents(featurefile, contents, feature_id)
def parse_contents(
self, featurefile_path: Path, featurefile_contents: str, feature_id: int = 0
):
# evaluate the language for the Feature File content
language_spec = self._detect_language(featurefile_contents)
# prepare the transformer for the Feature File
if self._transformer is not None:
self._transformer.prepare(
language_spec, featurefile_path, featurefile_contents, feature_id
)
# get a parser
parser = self._get_parser(language_spec)
try:
ast = parser.parse(featurefile_contents)
except UnexpectedInput as exc:
exc_class = exc.match_examples(
parser.parse,
{
RadishMissingFeatureShortDescription: RadishMissingFeatureShortDescription.examples, # noqa
RadishMissingRuleShortDescription: RadishMissingRuleShortDescription.examples,
RadishMissingScenarioShortDescription: RadishMissingScenarioShortDescription.examples, # noqa
RadishMisplacedBackground: RadishMisplacedBackground.examples,
RadishStepDoesNotStartWithKeyword: RadishStepDoesNotStartWithKeyword.examples,
RadishStepDocStringNotClosed: RadishStepDocStringNotClosed.examples,
RadishScenarioOutlineWithoutExamples: RadishScenarioOutlineWithoutExamples.examples, # noqa
RadishScenarioOutlineExamplesMissingOpeningVBar: RadishScenarioOutlineExamplesMissingOpeningVBar.examples, # noqa
RadishMultipleBackgrounds: RadishMultipleBackgrounds.examples,
RadishStepDataTableMissingClosingVBar: RadishStepDataTableMissingClosingVBar.examples, # noqa
RadishScenarioLoopMissingIterations: RadishScenarioLoopMissingIterations.examples, # noqa
RadishScenarioLoopInvalidIterationsValue: RadishScenarioLoopInvalidIterationsValue.examples, # noqa
RadishScenarioOutlineExamplesMissingClosingVBar: RadishScenarioOutlineExamplesMissingClosingVBar.examples, # noqa
RadishScenarioOutlineExamplesInconsistentCellCount: RadishScenarioOutlineExamplesInconsistentCellCount.examples, # noqa
},
)
if not exc_class:
raise
raise exc_class(exc.get_context(featurefile_contents), exc.line, exc.column)
return ast
def _detect_language(self, featurefile_contents: str):
"""Detect the specified language in the first line of the Feature File
If no language code is detected ``en`` is used.
If an unknown language code is detected an error is raised.
"""
def __get_language_spec(code):
language_spec_path = (
Path(__file__).parent / "languages" / "{}.json".format(code)
)
if not language_spec_path.exists():
raise RadishLanguageNotFound(code)
with open(
str(language_spec_path), "r", encoding="utf-8"
) as language_spec_file:
keywords = json.load(language_spec_file)
return LanguageSpec(code, keywords)
match = re.match(
r"^#\s*language:\s*(?P<code>[a-zA-Z-]{2,})", featurefile_contents.lstrip()
)
language_code = match.groupdict()["code"] if match else "en"
return __get_language_spec(language_code)
def _resolve_preconditions(self, features_rootdir, ast, visited_features):
for scenario in (s for rules in ast.rules for s in rules.scenarios):
preconditions = []
for precondition_tag in (
t for t in scenario.tags if isinstance(t, PreconditionTag)
):
precondition_path = features_rootdir / precondition_tag.feature_filename
if precondition_path not in visited_features:
precondition_ast = self.parse_file(precondition_path)
visited_features[precondition_ast.path] = precondition_ast
self._resolve_preconditions(
features_rootdir, precondition_ast, visited_features
)
else:
precondition_ast = visited_features[precondition_path]
precondition_scenarios = (
s for rules in precondition_ast.rules for s in rules.scenarios
)
for precondition_scenario in precondition_scenarios:
if (
precondition_scenario.short_description
== precondition_tag.scenario_short_description
):
break
else:
raise RadishPreconditionScenarioDoesNotExist(
precondition_path,
precondition_tag.scenario_short_description,
(
s.short_description
for rules in ast.rules
for s in rules.scenarios
),
)
# check if the precondition leads to a recursion
if (
precondition_scenario in preconditions
or precondition_scenario == scenario
):
raise RadishPreconditionScenarioRecursion(
scenario, precondition_scenario
)
preconditions.append(precondition_scenario)
# assign preconditions
scenario.set_preconditions(preconditions)
|
benchmarks/compare.py | novak2000/n2 | 528 | 11100205 | <gh_stars>100-1000
import os
import re
import argparse
from collections import defaultdict
def parse(args):
data = defaultdict(dict)
for line in open(args.fname):
library, algo, _, search_elapsed, accuracy, _ = line.strip().split('\t')
data[library.split(' ')[0]][algo] = float(search_elapsed), float(accuracy)
return data[args.base_lib], data[args.target_lib]
def compare(base, target):
def natural_sort(l):
def alphanum_key(key):
def convert(text):
return int(text) if text.isdigit() else text.lower()
return [convert(c) for c in re.split('([0-9]+)', key)]
return sorted(l, key=alphanum_key)
print('algo\tsearch_elapsed_seconds(negative values are better)\taccuracy(positive values are better)')
for key in natural_sort(target.keys()):
if key in base:
print('%s\t%s' % (key, '\t'.join(str(round((z[0] - z[1]) * 100 / z[1], 2)) + ' %'
for z in zip(target[key], base[key]))))
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--base_lib', help='base library to compare')
parser.add_argument('--target_lib', help='target library to compare')
parser.add_argument('fname', help='result file path')
args = parser.parse_args()
if not os.path.exists(args.fname):
raise ValueError("Wrong result file path")
compare(*parse(args))
|
examples/monitoring/init_grafana.py | DNCoelho/clipper | 1,403 | 11100260 | import signal
import requests
import docker
import json
import time
import sys
def signal_handler(signal, frame):
print("Stopping Grafana...")
docker_client = client.from_env()
try:
grafana = [
c for c in docker_client.containers.list()
if c.attrs['Config']['Image'] == "grafana/grafana"
][0]
grafana.stop()
except Exception as e:
pass
sys.exit(0)
if __name__ == '__main__':
signal.signal(signal.SIGINT, signal_handler)
print("(1/3) Initializing Grafana")
client = docker.from_env()
container = client.containers.run(
"grafana/grafana:latest", ports={'3000/tcp': 3000}, detach=True)
print("(2/3) Grafana Initialized")
time.sleep(3)
with open('Clipper_DataSource.json', 'r') as f:
datasource = json.load(f)
requests.post(
'http://admin:admin@localhost:3000/api/datasources', data=datasource)
print('(3/3) Clipper Data Source Added')
print(
'Please login to http://localhost:3000 using username and password "admin"'
)
print('''
After Login, Click "Home" -> "Import Dashboard" -> "Upload json File" -> "Clipper_Dashboard.json"
''')
while True:
time.sleep(1)
|
examples/embeddings_extraction_s3e_pooling.py | skiran252/FARM | 1,551 | 11100284 | import logging
import pickle
from pathlib import Path
from farm.data_handler.processor import InferenceProcessor
from farm.infer import Inferencer
from farm.modeling.adaptive_model import AdaptiveModel
from farm.modeling.language_model import LanguageModel
from farm.modeling.tokenization import Tokenizer
from farm.utils import set_all_seeds, initialize_device_settings
from farm.modeling.wordembedding_utils import fit_s3e_on_corpus
logger = logging.getLogger(__name__)
"""
Example for generating sentence embeddings via the S3E pooling approach as described by Wang et al in the paper
"Efficient Sentence Embedding via Semantic Subspace Analysis"
(https://arxiv.org/abs/2002.09620)
You can use classical models like fasttext, glove or word2vec and apply S3E on top.
This can be a powerful benchmark for plain transformer-based embeddings.
First, we fit the required stats on a custom corpus. This includes the derivation of token_weights depending on
token occurences in the corpus, creation of the semantic clusters via k-means and a couple of
pre-/post-processing steps to normalize the embeddings.
Second, we feed the resulting objects into our Inferencer to extract the actual sentence embeddings for our sentences.
"""
def fit(language_model, corpus_path, save_dir, do_lower_case, batch_size=4, use_gpu=False):
# Fit S3E on a corpus
set_all_seeds(seed=42)
device, n_gpu = initialize_device_settings(use_cuda=use_gpu, use_amp=False)
# Create a InferenceProcessor
tokenizer = Tokenizer.load(pretrained_model_name_or_path=language_model, do_lower_case=do_lower_case)
processor = InferenceProcessor(tokenizer=tokenizer, max_seq_len=128)
# Create an AdaptiveModel
language_model = LanguageModel.load(language_model)
model = AdaptiveModel(
language_model=language_model,
prediction_heads=[],
embeds_dropout_prob=0.1,
lm_output_types=["per_sequence"],
device=device)
model, processor, s3e_stats = fit_s3e_on_corpus(processor=processor,
model=model,
corpus=corpus_path,
n_clusters=10,
pca_n_components=300,
svd_postprocessing=True,
min_token_occurrences=1)
# save everything to allow inference without fitting everything again
model.save(save_dir)
processor.save(save_dir)
with open(save_dir / "s3e_stats.pkl", "wb") as f:
pickle.dump(s3e_stats, f)
# Load model, tokenizer and processor directly into Inferencer
inferencer = Inferencer(model=model, processor=processor, task_type="embeddings", gpu=use_gpu,
batch_size=batch_size, extraction_strategy="s3e", extraction_layer=-1,
s3e_stats=s3e_stats)
# Input
basic_texts = [
{"text": "a man is walking on the street."},
{"text": "a woman is walking on the street."},
]
# Get embeddings for input text (you can vary the strategy and layer)
result = inferencer.inference_from_dicts(dicts=basic_texts)
print(result)
inferencer.close_multiprocessing_pool()
def extract_embeddings(load_dir, use_gpu, batch_size):
with open(load_dir / "s3e_stats.pkl", "rb") as f:
s3e_stats = pickle.load(f)
# Init inferencer
inferencer = Inferencer.load(model_name_or_path=load_dir, task_type="embeddings", gpu=use_gpu,
batch_size=batch_size, extraction_strategy="s3e", extraction_layer=-1,
s3e_stats=s3e_stats)
# Input
basic_texts = [
{"text": "a man is walking on the street."},
{"text": "a woman is walking on the street."},
]
# Get embeddings for input text
result = inferencer.inference_from_dicts(dicts=basic_texts)
print(result)
inferencer.close_multiprocessing_pool()
if __name__ == "__main__":
lang_model = "glove-english-uncased-6B"
do_lower_case = True
# You can download this from:
# "https://s3.eu-central-1.amazonaws.com/deepset.ai-farm-downstream/lm_finetune_nips.tar.gz"
corpus_path = Path("../data/lm_finetune_nips/train.txt")
s3e_dir = Path("../saved_models/fitted_s3e/")
fit(language_model=lang_model,
do_lower_case=do_lower_case,
corpus_path=corpus_path,
save_dir=s3e_dir
)
extract_embeddings(load_dir=s3e_dir, use_gpu=False, batch_size=10) |
AutoDL_sample_code_submission/Auto_Tabular/feature/feat_engine.py | dianjixz/AutoDL | 1,044 | 11100286 | <gh_stars>1000+
from .feat_gen import *
from sklearn.utils import shuffle
from Auto_Tabular.utils.log_utils import log ,timeit
class FeatEngine:
def __init__(self):
self.order2s = []
def fit(self, data_space, order):
if order != 2:
return
order_name = 'order{}s'.format(order)
pipline = getattr(self, order_name)
self.feats = []
for feat_cls in pipline:
feat = feat_cls()
feat.fit(data_space)
self.feats.append(feat)
def transform(self, data_space, order):
for feat in self.feats:
feat.transform(data_space)
@timeit
def fit_transform(self, data_space, order, info=None):
if order != 2:
return
order_name = 'order{}s'.format(order)
pipline = getattr(self, order_name)
X, y = data_space.data, data_space.y
cats = data_space.cat_cols
for feat_cls in pipline:
feat = feat_cls()
feat.fit_transform(X, y, cat_cols=cats, num_cols=info['imp_nums'])
data_space.data = X
data_space.update = True
|
pythainlp/tokenize/sefr_cut.py | Gorlph/pythainlp | 569 | 11100287 | # -*- coding: utf-8 -*-
"""
Wrapper for SEFR CUT Thai word segmentation. SEFR CUT is a
Thai Word Segmentation Models using Stacked Ensemble.
:See Also:
* `GitHub repository <https://github.com/mrpeerat/SEFR_CUT>`_
"""
from typing import List
import sefr_cut
DEFAULT_ENGINE = 'ws1000'
sefr_cut.load_model(engine=DEFAULT_ENGINE)
def segment(text: str, engine: str = 'ws1000') -> List[str]:
global DEFAULT_ENGINE
if not text or not isinstance(text, str):
return []
if engine != DEFAULT_ENGINE:
DEFAULT_ENGINE = engine
sefr_cut.load_model(engine=DEFAULT_ENGINE)
return sefr_cut.tokenize(text)[0]
|
tests/test_concordance.py | baileythegreen/pyani | 144 | 11100324 | <gh_stars>100-1000
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# (c) The James Hutton Institute 2016-2019
# (c) University of Strathclyde 2019-2020
# Author: <NAME>
#
# Contact:
# <EMAIL>
#
# <NAME>,
# Strathclyde Institute for Pharmacy and Biomedical Sciences,
# 161 Cathedral Street,
# Glasgow,
# G4 0RE
# Scotland,
# UK
#
# The MIT License
#
# Copyright (c) 2016-2019 The James Hutton Institute
# Copyright (c) 2019-2020 University of Strathclyde
#
# 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.
"""Test for concordance of pyani package output with JSpecies.
These tests are intended to be run from the repository root using:
pytest -v
print() statements will be caught by nosetests unless there is an
error. They can also be recovered with the -s option.
"""
import unittest
from pathlib import Path
import pandas as pd
import pytest
from pyani import run_multiprocessing as run_mp
from pyani import anib, anim, tetra, pyani_files
def parse_jspecies(infile):
"""Parse JSpecies output into Pandas dataframes.
The function expects a single file containing (legacy) ANIb,
ANIm, and TETRA output.
:param infile: path to JSpecies output file
This is an ugly function!
"""
dfs = dict()
methods = ("ANIm", "ANIb", "Tetra")
with open(infile, "r") as ifh:
header, in_table = False, False
for line in [_.strip() for _ in ifh.readlines() + ["\n"]]:
if line in methods and not in_table:
mth, header = line, True
elif header:
columns = line.split("\t")
data = pd.DataFrame(index=columns, columns=columns)
in_table, header = True, False
elif in_table:
if not line:
dfs[mth] = data.sort_index(axis=0).sort_index(axis=1)
in_table = False
else:
ldata = line.split("\t")
row = ldata[0]
for idx, val in enumerate(ldata[1:]):
if val != "---":
data[columns[idx]][row] = float(val)
elif mth.startswith("ANI"):
data[columns[idx]][row] = 100.0
else:
data[columns[idx]][row] = 1.0
else:
pass
return dfs
@pytest.fixture
def paths_concordance_fna(path_fixtures_base):
"""Paths to FASTA inputs for concordance analysis."""
return [
_
for _ in (path_fixtures_base / "concordance").iterdir()
if _.is_file() and _.suffix == ".fna"
]
@pytest.fixture
def path_concordance_jspecies(path_fixtures_base):
"""Path to JSpecies analysis output."""
return path_fixtures_base / "concordance/jspecies_output.tab"
@pytest.fixture
def threshold_anib_lo_hi():
"""Threshold for concordance comparison split between high and low identity.
When comparing ANIb results with ANIblastall results, we need to account for
the differing performances of BLASTN and BLASTN+ on more distantly-related
sequences. On closely-related sequences both methods give similar results;
for more distantly-related sequences, the results can be quite different. This
threshold is the percentage identity we consider to separate "close" from
"distant" related sequences.
"""
return 90
@pytest.fixture
def tolerance_anib_hi():
"""Tolerance for ANIb concordance comparisons.
This tolerance is for comparisons between "high identity" comparisons, i.e.
genomes having identity greater than threshold_anib_lo_hi in homologous regions.
These "within-species" level comparisons need to be more accurate
"""
return 0.1
@pytest.fixture
def tolerance_anib_lo():
"""Tolerance for ANIb concordance comparisons.
This tolerance is for comparisons between "low identity" comparisons, i.e.
genomes having identity less than threshold_anib_lo_hi in homologous regions.
These "intra-species" level comparisons vary more as a result of the change of
algorithm from BLASTN to BLASTN+ (megablast).
"""
return 5
@pytest.fixture
def tolerance_anim():
"""Tolerance for ANIm concordance comparisons."""
return 0.1
@pytest.fixture
def tolerance_tetra():
"""Tolerance for TETRA concordance comparisons."""
return 0.1
@pytest.mark.skip_if_exe_missing("nucmer")
def test_anim_concordance(
paths_concordance_fna, path_concordance_jspecies, tolerance_anim, tmp_path
):
"""Check ANIm results are concordant with JSpecies."""
# Perform ANIm on the input directory contents
# We have to separate nucmer/delta-filter command generation
# because Travis-CI doesn't play nicely with changes we made
# for local SGE/OGE integration.
# This might be avoidable with a scheduler flag passed to
# jobgroup generation in the anim.py module. That's a TODO.
ncmds, fcmds = anim.generate_nucmer_commands(paths_concordance_fna, tmp_path)
(tmp_path / "nucmer_output").mkdir(exist_ok=True, parents=True)
run_mp.multiprocessing_run(ncmds)
# delta-filter commands need to be treated with care for
# Travis-CI. Our cluster won't take redirection or semicolon
# separation in individual commands, but the wrapper we wrote
# for this (delta_filter_wrapper.py) can't be called under
# Travis-CI. So we must deconstruct the commands below
dfcmds = [
" > ".join([" ".join(fcmd.split()[1:-1]), fcmd.split()[-1]]) for fcmd in fcmds
]
run_mp.multiprocessing_run(dfcmds)
orglengths = pyani_files.get_sequence_lengths(paths_concordance_fna)
results = anim.process_deltadir(tmp_path / "nucmer_output", orglengths)
result_pid = results.percentage_identity
result_pid.to_csv(tmp_path / "pyani_anim.tab", sep="\t")
# Compare JSpecies output to results
result_pid = (result_pid.sort_index(axis=0).sort_index(axis=1) * 100.0).values
tgt_pid = parse_jspecies(path_concordance_jspecies)["ANIm"].values
assert result_pid - tgt_pid == pytest.approx(0, abs=tolerance_anim)
@pytest.mark.skip_if_exe_missing("blastn")
def test_anib_concordance(
paths_concordance_fna,
path_concordance_jspecies,
tolerance_anib_hi,
tolerance_anib_lo,
threshold_anib_lo_hi,
fragment_length,
tmp_path,
):
"""Check ANIb results are concordant with JSpecies.
We expect ANIb results to be quite different, as the BLASTN
algorithm changed substantially between BLAST and BLAST+ (the
megaBLAST algorithm is now the default for BLASTN)
"""
# Get lengths of input genomes
orglengths = pyani_files.get_sequence_lengths(paths_concordance_fna)
# Build and run BLAST jobs
fragfiles, fraglengths = anib.fragment_fasta_files(
paths_concordance_fna, tmp_path, fragment_length
)
jobgraph = anib.make_job_graph(
paths_concordance_fna, fragfiles, anib.make_blastcmd_builder("ANIb", tmp_path)
)
assert 0 == run_mp.run_dependency_graph(jobgraph) # Jobs must run correctly
# Process BLAST output
result_pid = anib.process_blast(
tmp_path, orglengths, fraglengths, mode="ANIb"
).percentage_identity
# Compare JSpecies output to results. We do this in two blocks,
# masked according to whether the expected result is greater than
# a threshold separating "low" from "high" identity comparisons.
result_pid = result_pid.sort_index(axis=0).sort_index(axis=1) * 100.0
lo_result = result_pid.mask(result_pid >= threshold_anib_lo_hi).fillna(0).values
hi_result = result_pid.mask(result_pid < threshold_anib_lo_hi).fillna(0).values
tgt_pid = parse_jspecies(path_concordance_jspecies)["ANIb"]
lo_target = tgt_pid.mask(tgt_pid >= threshold_anib_lo_hi).fillna(0).values
hi_target = tgt_pid.mask(tgt_pid < threshold_anib_lo_hi).fillna(0).values
assert (lo_result - lo_target, hi_result - hi_target) == (
pytest.approx(0, abs=tolerance_anib_lo),
pytest.approx(0, abs=tolerance_anib_hi),
)
@pytest.mark.skip_if_exe_missing("blastall")
def test_aniblastall_concordance(
paths_concordance_fna,
path_concordance_jspecies,
tolerance_anib_hi,
fragment_length,
tmp_path,
):
"""Check ANIblastall results are concordant with JSpecies."""
# Get lengths of input genomes
orglengths = pyani_files.get_sequence_lengths(paths_concordance_fna)
# Perform ANIblastall on the input directory contents
fragfiles, fraglengths = anib.fragment_fasta_files(
paths_concordance_fna, tmp_path, fragment_length
)
jobgraph = anib.make_job_graph(
paths_concordance_fna,
fragfiles,
anib.make_blastcmd_builder("ANIblastall", tmp_path),
)
assert 0 == run_mp.run_dependency_graph(jobgraph) # Jobs must run correctly
# Process BLAST output
result_pid = anib.process_blast(
tmp_path, orglengths, fraglengths, mode="ANIblastall"
).percentage_identity
# Compare JSpecies output to results
result_pid = (result_pid.sort_index(axis=0).sort_index(axis=1) * 100.0).values
tgt_pid = parse_jspecies(path_concordance_jspecies)["ANIb"].values
assert result_pid - tgt_pid == pytest.approx(0, abs=tolerance_anib_hi)
def test_tetra_concordance(
paths_concordance_fna, path_concordance_jspecies, tolerance_tetra, tmp_path
):
"""Check TETRA results are concordant with JSpecies."""
# Perform TETRA analysis
zscores = dict()
for filename in paths_concordance_fna:
zscores[filename.stem] = tetra.calculate_tetra_zscore(filename)
results = tetra.calculate_correlations(zscores).values
# Compare JSpecies output
tgt_mat = parse_jspecies(path_concordance_jspecies)["Tetra"].values
assert results - tgt_mat == pytest.approx(0, abs=tolerance_tetra)
|
geoq/ontology/models.py | kaydoh/geoq | 471 | 11100329 | from django.db import models
from django.urls import reverse_lazy
from django.contrib.gis import admin
import json
class Term(models.Model):
"""
Ontological Term
"""
TERM_TYPES = [("Object", "Object"), ("Property", "Property"), ("Relationship","Relationship")]
word = models.CharField(max_length=100, help_text="Value of term")
identifier = models.CharField(max_length=200, help_text="IRI Identifier")
type = models.CharField(max_length=30, choices=TERM_TYPES, default=TERM_TYPES[0])
def __unicode__(self):
return self.word
def __str__(self):
return self.__unicode__()
@property
def serialize(self):
return {"name": self.word, "identifier": self.identifier, "type": self.type}
class Vocabulary(models.Model):
"""
Model for ontology vocabulary.
"""
name = models.CharField(max_length=200, help_text="Name of Vocabulary")
terms = models.ManyToManyField(Term, related_name="entries")
def __unicode__(self):
return self.name
def __str__(self):
return self.name
@property
def toJson(self):
return json.dumps([t.serialize for t in self.terms.all()])
class Ontology(models.Model):
"""
Representation of an Ontology
"""
name = models.CharField(max_length=200, help_text="Ontology Name")
url = models.CharField(max_length=200, help_text="Location of ontology")
def __unicode__(self):
return self.name
def __str__(self):
return self.name
|
deep-rl/lib/python2.7/site-packages/OpenGL/GLX/NV/video_capture.py | ShujaKhalid/deep-rl | 210 | 11100331 | '''OpenGL extension NV.video_capture
This module customises the behaviour of the
OpenGL.raw.GLX.NV.video_capture to provide a more
Python-friendly API
Overview (from the spec)
This extension provides a mechanism for streaming video data
directly into texture objects and buffer objects. Applications can
then display video streams in interactive 3D scenes and/or
manipulate the video data using the GL's image processing
capabilities.
The official definition of this extension is available here:
http://www.opengl.org/registry/specs/NV/video_capture.txt
'''
from OpenGL import platform, constant, arrays
from OpenGL import extensions, wrapper
import ctypes
from OpenGL.raw.GLX import _types, _glgets
from OpenGL.raw.GLX.NV.video_capture import *
from OpenGL.raw.GLX.NV.video_capture import _EXTENSION_NAME
def glInitVideoCaptureNV():
'''Return boolean indicating whether this extension is available'''
from OpenGL import extensions
return extensions.hasGLExtension( _EXTENSION_NAME )
### END AUTOGENERATED SECTION |
px/px_file.py | walles/px | 149 | 11100367 | import socket
from . import px_exec_util
import sys
if sys.version_info.major >= 3:
# For mypy PEP-484 static typing validation
from typing import Set # NOQA
from typing import List # NOQA
from typing import Tuple # NOQA
from typing import Iterable # NOQA
from typing import Optional # NOQA
class PxFileBuilder:
def __init__(self):
self.fd = None # type: Optional[int]
self.pid = None # type: Optional[int]
self.name = None # type: Optional[str]
self.type = None # type: Optional[str]
self.inode = None # type: Optional[str]
self.device = None # type: Optional[str]
self.access = None # type: Optional[str]
# Example values: "cwd", "txt" and probably others as well
self.fdtype = None # type: Optional[str]
def build(self):
# type: () -> PxFile
assert self.pid is not None
assert self.type
pxFile = PxFile(self.pid, self.type)
pxFile.name = self.name
pxFile.fd = self.fd
pxFile.inode = self.inode
pxFile.device = self.device
pxFile.access = self.access
pxFile.fdtype = self.fdtype
return pxFile
def __repr__(self):
return "PxFileBuilder(pid={}, name={}, type={})".format(
self.pid, self.name, self.type
)
class PxFile(object):
def __init__(self, pid, filetype):
# type: (int, str) -> None
self.fd = None # type: Optional[int]
self.pid = pid
self.type = filetype
self.name = None # type: Optional[str]
self.inode = None # type: Optional[str]
self.device = None # type: Optional[str]
self.access = None # type: Optional[str]
# Example values: "cwd", "txt" and probably others as well
self.fdtype = None # type: Optional[str]
def __repr__(self):
# The point of implementing this method is to make the py.test output
# more readable.
return str(self.pid) + ":" + str(self)
def __eq__(self, other):
return self.__dict__ == other.__dict__
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return hash((self.name, self.fd, self.fdtype, self.pid))
def __str__(self):
if self.type == "REG":
return self.name
name = self.name
listen_suffix = ""
if self.type in ["IPv4", "IPv6"]:
local, remote_endpoint = self.get_endpoints()
if not remote_endpoint:
listen_suffix = " (LISTEN)"
name = self._resolve_name()
# Decorate non-regular files with their type
if name:
return "[" + self.type + "] " + name + listen_suffix
return "[" + self.type + "] " + listen_suffix
def _resolve_name(self):
local, remote = self.get_endpoints()
if not local:
return self.name
local = resolve_endpoint(local)
if not remote:
return local
return local + "->" + resolve_endpoint(remote)
def device_number(self):
if self.device is None:
return None
number = int(self.device, 16)
if number == 0:
# 0x000lotsofmore000 is what we get on lsof 4.86 and Linux 4.2.0
# when lsof doesn't have root privileges
return None
return number
def fifo_id(self):
if self.inode is not None:
# On Linux, pipes are presented by lsof as FIFOs. They have unique-
# per-pipe inodes, so we use them as IDs.
return self.inode
if self.type == "FIFO" and self.name == "pipe":
# This is just a label that can be shared by several pipes on Linux,
# we can't use it to identify a pipe.
return None
if self.type == "PIPE" and self.name == "(none)":
# This is just a label that can be shared by several pipes on OS X,
# we can't use it to identify a pipe.
return None
# On OS X, pipes are presented as PIPEs and lack inodes, but they
# compensate by having unique names.
return self.name
def get_endpoints(self):
# type: () -> Tuple[Optional[str], Optional[str]]
"""
Returns a (local,remote) tuple. They represent the local and the remote
endpoints of a network connection.
This method will never return None, but both local and remote can be
None in case this isn't a network connection for example.
"""
if not self.name:
return (None, None)
if self.type not in ["IPv4", "IPv6"]:
return (None, None)
local = None
remote = None
split_name = self.name.split("->")
local = split_name[0]
# Turn "localhost:ipp (LISTEN)" into "ipp" and nothing else
local = local.split(" ")[0]
if "*" in local:
# We can't match against this endpoint
local = None
if len(split_name) == 2:
remote = split_name[1]
return (local, remote)
def resolve_endpoint(endpoint):
# type: (str) -> str
"""
Resolves "127.0.0.1:portnumber" into "localhost:portnumber".
"""
# Find the rightmost :, necessary for IPv6 addresses
splitindex = endpoint.rfind(":")
if splitindex == -1:
return endpoint
address = endpoint[0:splitindex]
if address[0] == "[" and address[-1] == "]":
# This is how lsof presents IPv6 addresses
address = address[1:-1]
port = endpoint[splitindex + 1 :]
host = None
try:
host = socket.gethostbyaddr(address)[0]
except Exception:
# Lookup failed for whatever reason, give up
return endpoint
if host == "localhost.localdomain":
# "localdomain" is just a long word that doesn't add any information
host = "localhost"
return host + ":" + port
def call_lsof():
"""
Call lsof and return the result as one big string
"""
# See OUTPUT FOR OTHER PROGRAMS: http://linux.die.net/man/8/lsof
# Output lines can be in one of two formats:
# 1. "pPID@" (with @ meaning NUL)
# 2. "fFD@aACCESSMODE@tTYPE@nNAME@"
return px_exec_util.run(["lsof", "-n", "-F", "fnaptd0i"])
def lsof_to_files(lsof):
# type: (str) -> List[PxFile]
"""
Convert lsof output into a files array.
"""
pid = None
file_builder = None # type: Optional[PxFileBuilder]
files = [] # type: List[PxFile]
for shard in lsof.split("\0"):
if shard[0] == "\n":
# Some shards start with newlines. Looks pretty when viewing the
# lsof output in moar, but makes the parsing code have to deal with
# it.
shard = shard[1:]
if not shard:
# The output ends with a single newline, which we just stripped away
break
infotype = shard[0]
value = shard[1:]
if infotype == "p":
pid = int(value)
elif infotype == "f":
if file_builder:
files.append(file_builder.build())
else:
file_builder = PxFileBuilder()
# Reset the file builder object. This operation is on a hot path
# and doing without an extra object allocation here actually helps.
file_builder.__init__() # type: ignore
if value.isdigit():
file_builder.fd = int(value)
else:
# Words like "cwd", "txt" and probably others as well
file_builder.fdtype = value
assert pid is not None
file_builder.pid = pid
file_builder.type = "??"
elif infotype == "a":
assert file_builder is not None
access = {" ": None, "r": "r", "w": "w", "u": "rw"}[value]
file_builder.access = access
elif infotype == "t":
assert file_builder is not None
file_builder.type = value
elif infotype == "d":
assert file_builder is not None
file_builder.device = value
elif infotype == "n":
assert file_builder is not None
file_builder.name = value
elif infotype == "i":
assert file_builder is not None
file_builder.inode = value
else:
raise Exception(
"Unhandled type <{}> for shard <{}>".format(infotype, shard)
)
if file_builder:
# Don't forget the last file
files.append(file_builder.build())
return files
def get_all():
# type: () -> Set[PxFile]
"""
Get all files.
If a file_types array is specified, only files of the listed types will be
returned.
"""
return set(lsof_to_files(call_lsof()))
|
leaf/api/wrapper.py | guiqiqi/leaf | 119 | 11100374 | """API 函数的包装器"""
import sys
import json
import types
import logging
import datetime
import ipaddress
import traceback
from typing import Callable, Type, Dict,\
NoReturn, Optional, Iterable, Any
import bson
import mongoengine
from flask import g as _g
from flask import abort as _abort
from flask import request as _request
from flask import Response as _Response
from werkzeug.exceptions import HTTPException
from . import settings
from . import validator
from .. import rbac
from ..core import error
from ..core import modules
logger = logging.getLogger("leaf.api")
class __TypeConverter:
"""类型转换注册器"""
def __init__(self):
"""初始化一个转换注册表"""
self.__default = str # 默认转换器
self.__converters: Dict[Type, Callable[[Type], object]] = dict()
def set_default(self, default: Callable[[Type], object]) -> NoReturn:
"""设置默认转换器"""
self.__default = default
def register(self, typing: Type, _converter: Callable[[Type], object]):
"""注册一个转换器"""
self.__converters[typing] = _converter
def convert(self, obj: object, default: Optional[bool] = False) -> object:
"""
按照注册的顺序进行类型转换
当传入 default 参数为 true 时调用设置的默认转换器
"""
for _type, _converter in self.__converters.items():
if isinstance(obj, _type):
return _converter(obj)
if not default:
raise KeyError("can not find converter for type %s" %
str(type(obj)))
return self.__default(obj)
# 生成类型转换器实例
converter = __TypeConverter()
converter.set_default(str)
converter.register(bson.ObjectId, str)
converter.register(datetime.datetime, lambda obj: obj.isoformat())
converter.register(datetime.time, lambda obj: obj.isoformat)
converter.register(Exception, str)
converter.register(mongoengine.QuerySet, list)
converter.register(mongoengine.Document, lambda obj: obj.to_json())
converter.register(mongoengine.EmbeddedDocument, lambda obj: obj.to_json())
class Encoder(json.JSONEncoder):
"""
重写 json.JSONEncoder.default 函数
在其中加入自定义的类型转换
"""
# pylint: disable=method-hidden
# pylint: disable=arguments-differ
def default(self, obj):
"""设置类型转换"""
try:
return converter.convert(obj)
except KeyError as _error:
pass
return json.JSONEncoder.default(self, obj)
types.MethodType(default, json.JSONEncoder)
def jsonify(*args, **kwargs):
"""返回自定义格式的 JSON 数据包"""
response = _Response(
json.dumps(dict(*args, **kwargs), cls=Encoder),
mimetype="application/json")
# 增加跨域请求支持
if settings.HTTPResponseHeader.AddCORSSupport:
methods = settings.HTTPResponseHeader.SupportMethods
domain = settings.HTTPResponseHeader.CORSDomain
response.headers.add("Access-Control-Allow-Origin", domain)
response.headers.add("Access-Control-Allow-Methods", methods)
return response
def iplimit(allowed: Iterable[str]) -> Callable:
"""
一个 API 接口访问限制 (基于 IP 地址)
如果不在允许的 IP 列表范围内则返回 403:
@api.iplimit("127.0.0.1") -> only localhost
@api.iplimit("192.168.1.0/24") -> 192.168.1.1-255
@api.iplimit("0.0.0.0/0") -> all ip address
"""
def decorator(function: Callable) -> Callable:
"""函数包装器"""
networks = [ipaddress.ip_network(addr) for addr in allowed]
def wrapper(*args, **kwargs) -> object:
"""参数包装器"""
# 获取地址
address = ipaddress.ip_address(_request.remote_addr)
# 判断地址
for network in networks:
if address in network:
return function(*args, **kwargs)
return _abort(403)
# 重命名函数防止 overwriting existing endpoint function
wrapper.__name__ = function.__name__
return wrapper
return decorator
def require(pointname: str, checkuser: bool = False) -> Callable:
"""
一个权限验证装饰器:
pointname: 需要的权限点名称
checkuser: 是否获取用户给视图层处理:
0. 如果未启用按照正常的权限验证流程处理(即权限不足时403)
1. 如果启用了在权限验证不足时会:
0. 设置 g.operator: str - 通过数据库查询的用户信息
1. 设置 g.checkuser: bool = True
1. 将权限交予视图层函数处理
0. 通过 flask 获取 Bearer-Token 并验证用户的 JWT Token 是否合法
1. 通过 accesspoint 查询数据库所需要的访问级别
2. 如果可以访问返回函数值否则返回 403
"""
def decorator(function: Callable) -> Callable:
"""函数包装器"""
def wrapper(*args, **kwargs) -> Any:
"""参数包装器"""
# 检查是否启用开发模式的 JWT Token
_devmode = modules.server.debug
_devtoken = modules.server.devjwt
_gettoken = _request.headers.get("Authorization", str())
if _devmode and _devtoken == _gettoken:
return function(*args, **kwargs)
# 验证 token 是否正确
try:
payload: dict = validator.jwttoken(_gettoken)
except error.Error as _error:
logger.warning(_error)
return settings.Authorization.UnAuthorized(_error)
_g.checkuser: bool = False
_g.operator = payload.get(rbac.jwt.const.Payload.Audience)
# 检查用户权限是否符合要求
try:
diff: int = validator.permission(pointname, payload)
except bson.errors.InvalidId as _error:
logger.warning(_error)
return settings.Authorization.UnAuthorized(_error)
except rbac.error.AccessPointNotFound as _error:
logger.warning(_error)
if not settings.Authorization.ExecuteAPMissing:
return settings.Authorization.NotPermitted(_error)
return function(*args, **kwargs)
else:
# 如果权限符合 - 直接返回
# 如果权限不符合但是需要检查userid - 同样返回
if not diff or checkuser:
_g.checkuser = checkuser
return function(*args, **kwargs)
# 如果不需要手动检查userid, 权限也不正确则返回403
return settings.Authorization.NotPermitted(str(diff))
# 重命名函数防止 overwriting existing endpoint function
wrapper.__name__ = function.__name__
return wrapper
return decorator
def wrap(payload: str) -> Callable:
"""
一个API接口装饰器:
执行函数获取返回值
判断函数执行是否发生错误
如果发生错误则返回错误信息
payload - 要在数据包内放置数据的键
"""
def decorator(function: Callable) -> Callable:
"""函数包装器"""
def wrapper(*args, **kwargs) -> object:
"""参数包装器"""
response = dict()
# 尝试执行函数
try:
result = function(*args, **kwargs)
except error.Error as _error:
# 发生内部错误
response[settings.Response.Code] = _error.code
response[settings.Response.Message] = _error.message()
response[settings.Response.Description] = _error.description
logger.error(_error)
except HTTPException as _error:
# 主动抛出 HTTP 错误
return _error
# pylint: disable=broad-except
except Exception as _error:
# 发生未定义错误
code = settings.Response.Codes.Unknown
description = settings.Response.Descriptions.Unknown
response[settings.Response.Code] = code
response[settings.Response.Message] = str(_error)
response[settings.Response.Description] = description
# 保存堆栈信息
exenvior = sys.exc_info()
exstr = traceback.format_exception(*exenvior)
exstr = ''.join(exstr)
logger.error(exstr)
else:
# 未发生错误时 - 如果是 Response 类 直接返回
if isinstance(response, _Response):
return response
# 如果是普通数据
response[settings.Response.Code] = settings.Response.Codes.Success
response[settings.Response.Message] = settings.Response.Messages.Success
response[settings.Response.Description] = settings.Response.Descriptions.Success
response[payload] = result
return jsonify(response)
# 重命名函数防止 overwriting existing endpoint function
wrapper.__name__ = function.__name__
return wrapper
return decorator
|
script/gen_solver_table.py | carlosal1015/sfepy | 510 | 11100380 | <filename>script/gen_solver_table.py<gh_stars>100-1000
#!/usr/bin/env python
"""
Generate available solvers table for ReST documentation.
"""
from __future__ import absolute_import
import os.path as op
import sys
from argparse import ArgumentParser
sys.path.append('.')
import sfepy
from sfepy.base.base import load_classes
from sfepy.solvers import NonlinearSolver, TimeSteppingSolver, LinearSolver, \
EigenvalueSolver, QuadraticEVPSolver, OptimizationSolver
from sfepy.solvers.auto_fallback import AutoFallbackSolver
solver_by_type_table = [
[[AutoFallbackSolver], "Virtual Solvers with Automatic Fallback"],
[[TimeSteppingSolver], "Time-Stepping Solvers"],
[[NonlinearSolver], "Nonlinear Solvers"],
[[LinearSolver], "Linear Solvers"],
[[EigenvalueSolver], "Eigenvalue Problem Solvers"],
[[QuadraticEVPSolver], "Quadratic Eigenvalue Problem Solvers"],
[[OptimizationSolver], "Optimization Solvers"]
]
for i in enumerate(solver_by_type_table):
solver_by_type_table[i[0]][0] = \
load_classes(sfepy.solvers.solver_files,
solver_by_type_table[i[0]][0],
package_name='sfepy.solvers')
def trim(docstring):
"""Trim and split (doc)string."""
if not docstring:
return ''
# Convert tabs to spaces (following the normal Python rules)
# and split into a list of lines:
lines = docstring.expandtabs().splitlines()
# Determine minimum indentation (first line doesn't count):
indent = sys.maxsize
for line in lines[1:]:
stripped = line.lstrip()
if stripped:
indent = min(indent, len(line) - len(stripped))
# Remove indentation (first line is special):
trimmed = [lines[0].strip()]
if indent < sys.maxsize:
for line in lines[1:]:
trimmed.append(line[indent:].rstrip())
# Strip off trailing and leading blank lines:
while trimmed and not trimmed[-1]:
trimmed.pop()
while trimmed and not trimmed[0]:
trimmed.pop(0)
# Return a splitted string:
return trimmed
def typeset_solvers_table(fd, solver_table):
"""
Generate solvers table ReST output.
"""
rest_tag_start = '.. <%s>\n'
rest_tag_end = '.. </%s>\n'
for solver_type in solver_table:
fd.write(rest_tag_start % solver_type[1])
for name, cls in sorted(solver_type[0].items()):
fd.write('- :class:`%s <%s.%s>`: ' %
(name, cls.__module__, cls.__name__))
fd.write('%s\n' % trim(cls.__doc__)[0])
fd.write(rest_tag_end % solver_type[1])
fd.write('\n')
def typeset(fd):
"""
Utility function called by Sphinx.
"""
fd = open(fd, 'w')
typeset_solvers_table(fd, solver_by_type_table)
fd.close()
def gen_solver_table(app):
typeset(op.join(app.builder.srcdir, 'solver_table.rst'))
def setup(app):
app.connect('builder-inited', gen_solver_table)
def main():
parser = ArgumentParser(description=__doc__)
parser.add_argument(
"-v",
"--version",
action="version",
version="%(prog)s " + sfepy.__version__
)
parser.add_argument(
"-o",
"--output",
metavar="output_filename",
action="store",
dest="output_filename",
default="solver_table.rst",
)
options = parser.parse_args()
typeset(options.output_filename)
if __name__ == '__main__':
main()
|
osf/migrations/0075_merge_20171207_1511.py | gaybro8777/osf.io | 628 | 11100388 | <reponame>gaybro8777/osf.io<filename>osf/migrations/0075_merge_20171207_1511.py
# -*- coding: utf-8 -*-
# Generated by Django 1.11.7 on 2017-12-07 21:11
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('osf', '0074_parse_citation_styles'),
('osf', '0074_auto_20171207_1331'),
]
operations = [
]
|
ck/repo/module/choice/module.py | santosh653/ck | 480 | 11100405 | #
# Collective Knowledge (deal with choices)
#
# See CK LICENSE.txt for licensing details
# See CK COPYRIGHT.txt for copyright details
#
# Developer: <NAME>, <EMAIL>, http://fursin.net
#
cfg={} # Will be updated by CK (meta description of this module)
work={} # Will be updated by CK (temporal data)
ck=None # Will be updated by CK (initialized CK kernel)
# Local settings
##############################################################################
# Initialize module
def init(i):
"""
Input: {}
Output: {
return - return code = 0, if successful
> 0, if error
(error) - error text if return > 0
}
"""
return {'return':0}
##############################################################################
# Make next multi-dimensional choice (with state)
def make(i):
"""
Input: {
choices_desc - dict with description of choices (flat format)
choices_order - list of list of flat choice vectors to tune [[],[],...] -
list of list is needed to be able to enable indedepent
selection of groups of choices. For example, iterate
over all possible data set sizes + random flags per data set
choices_selection - list of dicts with types of selection for each above group
choices_current - current vector of choices
(random_module) - if !=None, random module with seed
(pipeline) - if set, update it with current choices
(custom_explore) - enforce exploration params from command line
(all) - if 'yes', select all
}
Output: {
return - return code = 0, if successful
> 0, if error
(error) - error text if return > 0
choices_current - list of updated choices
choices - dictionary of flat choices and values
choices_order - list of flat choices (to know order if need such as for LLVM opt)
pipeline - upated pipeline with choices
also choices and choices_order are added to pipeline
finish - if True, iterations are over
}
"""
from random import Random
o=i.get('out','')
my_random=i.get('random_module',None)
if my_random==None: my_random=Random()
finish=False
cdesc=i['choices_desc']
corder=i['choices_order']
csel=i['choices_selection']
ccur=i['choices_current']
pipeline=i.get('pipeline',{})
cexp=i.get('custom_explore',{})
cd=len(corder)
al=i.get('all','')
# Init current choices
if len(ccur)==0:
for c in range(0, cd):
cx=corder[c]
cy=[]
for k in range(0,len(cx)):
cy.append('')
ccur.append(cy)
update=False
nupdate=False # if force update next
for cx in range(cd-1,-1,-1):
cc=corder[cx]
dc=ccur[cx]
t={}
if al=='yes':
tp='pre-selected'
elif cexp.get('type','')!='':
tp=cexp['type']
else:
t=csel[cx]
tp=t.get('type','')
ti=t.get('iterations','')
top=t.get('omit_probability','')
if cexp.get('omit_probability','')!='': top=cexp['omit_probability']
if top=='': top=0.0
else: top=float(top)
# Take descriptions first directly from choices_selection.
# Later will be taken from choice_desc, if exists
zchoice=t.get('choice',[])
zprefix=t.get('explore_prefix','')
zdefault=t.get('default','')
zcanomit=t.get('can_omit','')
zestart=t.get('start','')
if cexp.get('start','')!='': zestart=cexp['start']
zestop=t.get('stop','')
if cexp.get('stop','')!='': zestop=cexp['stop']
zestep=t.get('step','')
if cexp.get('step','')!='': zestep=cexp['step']
if tp=='': tp='random'
ci=t.get('cur_iter','')
if ci=='': ci=-1
if cx==(cd-1) or update or nupdate or ci==-1:
nupdate=False
ci+=1
if ti!='' and ci>=ti:
ci=0
update=True
else:
update=False
dvsame=''
xupdate=False
for c in range(len(cc)-1,-1,-1):
cn=cc[c]
qt=cdesc.get(cn,{})
if zcanomit!='': yco=zcanomit
else: yco=qt.get('can_omit','')
if len(zchoice)>0: yhc=zchoice
else:
yhc=qt.get('choice',[])
if len(yhc)==0:
yhc=qt.get('choices',[])
if zprefix!='': yep=zprefix
else: yep=qt.get('explore_prefix','')
if tp!='': ytp=t.get('subtype','')
else: ytp=qt.get('type','')
if zdefault!='': ydefault=zdefault
else: ydefault=qt.get('default','')
dcc=dc[c]
if yep!='' and dcc.startswith(yep):
dcc=dcc[len(yep):]
if ytp=='float': dcc=float(dcc)
else: dcc=int(dcc)
if zestart!='': yestart=zestart
else: yestart=qt.get('explore_start','')
if zestop!='': yestop=zestop
else: yestop=qt.get('explore_stop','')
if zestep!='': yestep=zestep
else: yestep=qt.get('explore_step','')
if yestart!='':
if ytp=='float':
r1=float(yestart)
r2=float(yestop)
rs=float(yestep)
else:
r1=int(yestart)
r2=int(yestop)
rs=int(yestep)
rx=(r2-r1+1)/rs
dv=ydefault
# If exploration, set first
# if tp=='parallel-loop' or tp=='loop':
if yestart!='':
dv=r1
elif len(yhc)>0:
dv=yhc[0]
if tp=='pre-selected':
dv=dcc
elif ci!=0 or (tp=='random' or tp=='random-with-next'):
lcqx=len(yhc)
if tp=='random' or tp=='random-with-next':
omit=False
if yco=='yes':
x=my_random.randrange(0, 1000)
if x<(1000.0*top):
omit=True
if omit:
dv=''
else:
if lcqx>0:
ln=my_random.randrange(0, lcqx)
dv=yhc[ln]
elif yestart!='':
if (type(rx)==float or type(rx)==int or type(rx)==ck.type_long) and rx>=1:
y=my_random.randrange(0,int(rx))
else:
# alternatively should print inconsistency
y=0
dv=r1+(y*rs)
if tp=='random-with-next':
nupdate=True
elif tp=='parallel-random': # Change all dimensions at the same time (if explorable)!
lcqx=len(yhc)
if dvsame=='':
if lcqx>0:
ln=my_random.randrange(0, lcqx)
dvsame=yhc[ln]
elif yestart!='':
if (type(rx)==float or type(rx)==int or type(rx)==ck.type_long) and rx>=1:
y=my_random.randrange(0,int(rx))
else:
# alternatively should print inconsistency
y=0
dvsame=r1+(y*rs)
dv=dvsame
elif tp=='parallel-loop' or tp=='loop' or tp=='loop-with-next' or tp=='parallel-loop-with-next':
dv=dcc
if (tp=='parallel-loop' or tp=='parallel-loop-with-next') or c==len(cc)-1 or xupdate:
if yestart!='':
dv=dcc+rs
if dv>r2:
dv=r1
if tp=='loop': xupdate=True
else:
ci=0
update=True
else:
xupdate=False
else:
# Here we process choices instead of ranges)
ln=t.get('tmp_choice_position',0)
if dv=='':
ln=0
else:
if tp=='loop-with-next' or tp=='parallel-loop-with-next':
ln+=1
else:
if dv in yhc:
ln=yhc.index(dv)
ln+=1
else:
ln=0
t['tmp_choice_position']=ln
if ln<lcqx:
dv=yhc[ln]
xupdate=False
else:
# Next is wrong, but check compatibility with previous cases!
# dv=ydefault
dv=yhc[0]
if tp=='loop': xupdate=True
else:
ci=0
update=True
if tp=='loop-with-next' or tp=='parallel-loop-with-next':
nupdate=True
# Machine learning based probabilistic adaptive sampling of multi-dimensional
# design and optimization speaces via external plugin
# See our work on Collective Mind (2014/2015)
#
# NOTE: moved to external customized autotuner plugins (see autotune pipeline --custom_autotuner)
# elif tp=='machine-learning-based' or tp=='model-based' or tp=='adaptive' or tp=='plugin-based' or tp=='customized':
else:
return {'return':1, 'error':'unknown autotuning type ('+tp+')'}
if yep!='' and dv!='': dv=yep+str(dv)
dc[c]=dv
if xupdate:
update=True
t['cur_iter']=ci
corder1=[]
ccur1={}
if update: # means that all loops were updated
finish=True
else:
if o=='con':
ck.out('')
ck.out(' Vector of flattened and updated choices:')
ll=0
prt=[]
for q in range(0, len(corder)):
qq=corder[q]
vq=ccur[q]
for q1 in range(0, len(qq)):
qq1=qq[q1]
vq1=vq[q1]
corder1.append(qq1)
ccur1[qq1]=vq1
if o=='con':
if vq1!='':
if len(qq1)>ll: ll=len(qq1)
prt.append({'k':qq1, 'v':vq1})
rx=ck.set_by_flat_key({'dict':pipeline, 'key':qq1, 'value':vq1})
if rx['return']>0: return rx
pipeline=rx['dict']
# Flatten choices and values, and add to pipeline
# Useful if order of choices is important (say opt flags in LLVM)
# Will be decoded by a given pipeline, if needed
pipeline['choices_order']=corder1
# pipeline['choices']=ccur1
if o=='con' and len(prt)>0:
for q in prt:
k=q['k']
v=q['v']
j=ll-len(k)
x=' '*j
ck.out(' '+k+x+' : '+str(v))
return {'return':0, 'choices_current':ccur, 'choices_order':corder1, 'choices':ccur1, 'pipeline':pipeline, 'finish':finish}
##############################################################################
# select list
def select_list(i):
"""
Input: {
choices - simple text list of choices
(skip_enter) - if 'yes', do not select 0 when entering 0
(desc) - description for each choices entry (list of the same size as choices)
(swap_name) - if 'yes' show desc first and real name in brackets
}
Output: {
return - return code = 0, if successful
> 0, if error
(error) - error text if return > 0
choice - selected text
position - selected position in the choice list
}
"""
se=i.get('skip_enter','')
sn=(i.get('swap_name','')=='yes')
lst=i.get('choices',[])
dsc=i.get('desc',[])
zz={}
iz=0
for iz in range(0, len(lst)):
z=lst[iz]
zs=str(iz)
zz[zs]=z
if iz<len(dsc):
zd=dsc[iz]
if zd!='':
if sn:
z=zd+' ('+z+')'
else:
z+=' ('+zd+')'
ck.out(zs+') '+z)
iz+=1
ck.out('')
y='Select item'
if se!='yes': y+=' (or press Enter for 0)'
y+=': '
rx=ck.inp({'text':y})
x=rx['string'].strip()
if x=='' and se!='yes': x='0'
if x not in zz:
return {'return':1, 'error':'number is not recognized'}
dduoa=zz[x]
return {'return':0, 'choice':dduoa, 'position':x}
##############################################################################
# improved version of UOA selector over the version from CK kernel
##############################################################################
# Universal UOA selector
def select_uoa(i):
"""
Input: {
choices - list from search function
(skip_enter) - if 'yes', do not select 0 when user presses Enter
(skip_sort) - if 'yes', do not sort array
}
Output: {
return - return code = 0, if successful
> 0, if error
(error) - error text if return > 0
choice - data UOA
}
"""
se=i.get('skip_enter','')
lst=i.get('choices',[])
if i.get('skip_sort','')!='yes':
klst=sorted(lst, key=lambda v: v['data_uoa'])
else:
klst=lst
zz={}
iz=0
for z1 in klst:
z=z1['data_uid']
zu=z1['data_uoa']
zname=z1.get('info',{}).get('data_name','')
zs=str(iz)
zz[zs]=z
x=z
if zname!='' and zname!=zu: x=zname+', '+x
ck.out(zs+') '+zu+' ('+x+')')
iz+=1
ck.out('')
y='Select UOA'
if se!='yes': y+=' (or press Enter for 0)'
y+=': '
rx=ck.inp({'text':y})
x=rx['string'].strip()
if x=='' and se!='yes': x='0'
if x not in zz:
return {'return':1, 'error':'number is not recognized'}
dduoa=zz[x]
return {'return':0, 'choice':dduoa}
|
menpo/model/test/test_gmrf.py | apapaion/menpo | 311 | 11100406 | <reponame>apapaion/menpo<filename>menpo/model/test/test_gmrf.py<gh_stars>100-1000
import numpy as np
from numpy.testing import assert_almost_equal, assert_array_almost_equal
from menpo.shape import PointCloud, DirectedGraph, UndirectedGraph
from menpo.math import as_matrix
from .. import GMRFModel, GMRFVectorModel
def _compute_sum_cost_block_sparse(
samples, test_sample, graph, n_features_per_vertex, subtract_mean, mode
):
# create ndarray with data
data = as_matrix(samples, length=None, return_template=False)
# initialize cost
cost = 0.0
# for loop over the graph's edges
for e in graph.edges:
v1 = e[0]
v2 = e[1]
v1_from = v1 * n_features_per_vertex
v1_to = (v1 + 1) * n_features_per_vertex
v2_from = v2 * n_features_per_vertex
v2_to = (v2 + 1) * n_features_per_vertex
# slice data and test vector
y = test_sample.as_vector()
if mode == "concatenation":
x = np.hstack((data[:, v1_from:v1_to], data[:, v2_from:v2_to]))
y = np.hstack((y[v1_from:v1_to], y[v2_from:v2_to]))
else:
x = data[:, v1_from:v1_to] - data[:, v2_from:v2_to]
y = y[v1_from:v1_to] - y[v2_from:v2_to]
# compute mean and covariance
cov = np.linalg.inv(np.cov(x.T))
mean = np.mean(x, axis=0)
# compute and sum cost
if subtract_mean:
v = y - mean
else:
v = y
cost += v.dot(cov).T.dot(v)
return cost
def _compute_sum_cost_block_diagonal(
samples, test_sample, graph, n_features_per_vertex, subtract_mean
):
# create ndarray with data
data = as_matrix(samples, length=None, return_template=False)
# initialize cost
cost = 0.0
# for loop over the graph's edges
for v1 in graph.vertices:
v1_from = v1 * n_features_per_vertex
v1_to = (v1 + 1) * n_features_per_vertex
# slice data and test vector
y = test_sample.as_vector()
x = data[:, v1_from:v1_to]
y = y[v1_from:v1_to]
# compute mean and covariance
cov = np.linalg.inv(np.cov(x.T))
mean = np.mean(x, axis=0)
# compute and sum cost
if subtract_mean:
v = y - mean
else:
v = y
cost += v.dot(cov).T.dot(v)
return cost
def test_mahalanobis_distance():
# arguments values
mode_values = ["concatenation", "subtraction"]
n_features_per_vertex_values = [2, 3]
sparse_values = [True, False]
subtract_mean_values = [True, False]
n_components_values = [None, 30]
# create graph
n_vertices = 6
edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0]])
graphs = [
DirectedGraph.init_from_edges(edges, n_vertices),
UndirectedGraph(np.zeros((n_vertices, n_vertices))),
]
for n_features_per_vertex in n_features_per_vertex_values:
# create samples
n_samples = 50
samples = []
for i in range(n_samples):
samples.append(
PointCloud(np.random.rand(n_vertices, n_features_per_vertex))
)
test_sample = PointCloud(np.random.rand(n_vertices, n_features_per_vertex))
for graph in graphs:
for mode in mode_values:
for sparse in sparse_values:
for n_components in n_components_values:
# train GMRF
gmrf = GMRFModel(
samples,
graph,
mode=mode,
sparse=sparse,
n_components=n_components,
dtype=np.float64,
)
for subtract_mean in subtract_mean_values:
# compute costs
if graph.n_edges == 0:
cost1 = _compute_sum_cost_block_diagonal(
samples,
test_sample,
graph,
n_features_per_vertex,
subtract_mean,
)
else:
cost1 = _compute_sum_cost_block_sparse(
samples,
test_sample,
graph,
n_features_per_vertex,
subtract_mean,
mode,
)
cost2 = gmrf.mahalanobis_distance(
test_sample, subtract_mean=subtract_mean
)
assert_almost_equal(cost1, cost2)
def test_increment():
# arguments values
mode_values = ["concatenation", "subtraction"]
n_features_per_vertex_values = [2, 3]
sparse_values = [True, False]
n_components_values = [None, 30]
# create graph
n_vertices = 6
edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 0]])
graphs = [
DirectedGraph.init_from_edges(edges, n_vertices),
UndirectedGraph(np.zeros((n_vertices, n_vertices))),
]
for n_features_per_vertex in n_features_per_vertex_values:
# create samples
n_samples = 100
samples = []
for i in range(n_samples):
samples.append(np.random.rand(n_vertices * n_features_per_vertex))
for graph in graphs:
for mode in mode_values:
for sparse in sparse_values:
for n_components in n_components_values:
# Incremental GMRF
gmrf1 = GMRFVectorModel(
samples[:50],
graph,
mode=mode,
sparse=sparse,
n_components=n_components,
dtype=np.float64,
incremental=True,
)
gmrf1.increment(samples[50::])
# Non incremental GMRF
gmrf2 = GMRFVectorModel(
samples,
graph,
mode=mode,
sparse=sparse,
n_components=n_components,
dtype=np.float64,
)
# Compare
if sparse:
assert_array_almost_equal(
gmrf1.precision.todense(), gmrf2.precision.todense()
)
assert_array_almost_equal(gmrf1.mean_vector, gmrf2.mean_vector)
|
plugin/lighthouse/ui/coverage_combobox.py | x9090/lighthouse | 1,741 | 11100439 | <filename>plugin/lighthouse/ui/coverage_combobox.py
import logging
import weakref
from lighthouse.util import *
from lighthouse.util.qt import *
from lighthouse.util.disassembler import disassembler
logger = logging.getLogger("Lighthouse.UI.ComboBox")
#------------------------------------------------------------------------------
# Constants Definitions
#------------------------------------------------------------------------------
SEPARATOR = "seperator"
SEPARATOR_HEIGHT = 1 # pixels
ENTRY_USER = "USER"
ENTRY_SPECIAL = "SPECIAL"
COLUMN_COVERAGE_STRING = 0
COLUMN_DELETE = 1
#------------------------------------------------------------------------------
# Coverage ComboBox
#------------------------------------------------------------------------------
class CoverageComboBox(QtWidgets.QComboBox):
"""
The Coverage ComboBox UI for switching between loaded coverage.
I had to write an unnecessary amount of code to prototype the engaging
combobox experiences I was looking for.
But now that we have all the important combobox components subclassed
out (it was necessary, I promise), perhaps there are a few more
interesting and fun features we can add in the future.
"""
def __init__(self, director, parent=None):
super(CoverageComboBox, self).__init__(parent)
self.setObjectName(self.__class__.__name__)
self._director = director
# configure the widget for use
self._ui_init()
self.refresh_theme()
#--------------------------------------------------------------------------
# QComboBox Overloads
#--------------------------------------------------------------------------
def mouseReleaseEvent(self, e):
"""
Capture mouse release events on the QComboBox.
"""
# get the widget currently beneath the mouse event being handled
hovering = self.childAt(e.pos())
#
# if the hovered widget is the 'head' of the QComboBox, we assume
# the user has clicked it and should show the dropwdown 'popup'
#
# we must showPopup() ourselves because internal Qt logic for
# 'editable' comboboxes try to enter an editing mode for the field
# rather than expanding the dropdown.
#
# if you don't remember, our combobox is marked 'editable' to satisfy
# some internal Qt logic so that our 'Windows' draw style is used
#
if hovering == self.lineEdit():
self.showPopup()
e.accept()
return
# handle any other events as they normally should be
super(CoverageComboBox, self).mousePressEvent(e)
#--------------------------------------------------------------------------
# Initialization - UI
#--------------------------------------------------------------------------
def _ui_init(self):
"""
Initialize UI elements.
"""
# initialize a monospace font to use with our widget(s)
self._font = MonospaceFont()
self._font.setPointSizeF(normalize_to_dpi(10))
self._font_metrics = QtGui.QFontMetricsF(self._font)
self.setFont(self._font)
# create the underlying model & table to power the combobox dropwdown
self.setModel(CoverageComboBoxModel(self._director, self))
self.setView(CoverageComboBoxView(self.model(), self))
#
# in the interest of maintaining a more consistent cross-platform
# style for the coverage combobox and its dropdown, we use an
# 'editable' QComboBox with the 'Windows' Qt style.
#
# since we don't actually want the QCombobox to be editable, we
# do everything we can to make it readonly / non-interfaceable.
#
self.setEditable(True)
self.lineEdit().setFont(self._font)
self.lineEdit().setReadOnly(True) # text can't be edited
self.lineEdit().setEnabled(False) # text can't be selected
#
# the combobox will pick a size based on its contents when it is first
# made visible, but we also make it is arbitrarily resizable for the
# user to change and play with at their own leisure
#
self.setSizeAdjustPolicy(QtWidgets.QComboBox.AdjustToContentsOnFirstShow)
self.setSizePolicy(QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Ignored)
self.setMaximumHeight(self._font_metrics.height()*1.75)
# draw the QComboBox with a 'Windows'-esque style
self.setStyle(QtWidgets.QStyleFactory.create("Windows"))
# connect relevant signals
self._ui_init_signals()
def _ui_init_signals(self):
"""
Connect UI signals.
"""
# combobox selection was changed
self.activated.connect(self._ui_selection_changed)
# the 'X' / delete icon was clicked on a dropdown entry
self.view().clicked.connect(self._ui_clicked_delete)
# register for cues from the director
self._director.coverage_switched(self._internal_refresh)
self._director.coverage_modified(self._internal_refresh)
#--------------------------------------------------------------------------
# Signal Handlers
#--------------------------------------------------------------------------
def _ui_clicked_delete(self, index):
"""
Handle a click on the 'X' delete icon (cell) on a dropdown entry.
"""
if not index.isValid():
return
#
# the dropdown popup is actually a 2D table. column 0 is the detailed
# coverage string, where column '1' is actually the delete 'X' icon.
#
# this is a sanity check to ensure that the clicked index is actually
# the deletion column. It should not be possible for column 0 (the
# detail string) to pass through here, as that will be captured by
# the default combobox signal handlers.
#
# the reason the deletion column clicks can pass through is because
# the model has technically marked their cells as 'un-selectable'
# through the flags() overload.
#
assert index.column() == COLUMN_DELETE, "Unexpected Column (%u)" % index.column()
#
# using the table cell index that was clicked, we want to lookup the
# coverage name that this 'X' icon/cell is associated with.
#
# we retrieve the associated coverage name from the 'UserRole' field
# of the model using the clicked index. The 'UserRole' is a Qt field
# we are free to store developer/misc data in
#
coverage_name = self.model().data(index, QtCore.Qt.UserRole)
assert coverage_name
# pass the deletion request onto the director to delete said coverage
self._director.delete_coverage(coverage_name)
# refresh the dropdown (it will remove the deleted entry from the UI)
self.showPopup()
#
# I don't want there to be any entries highlighted after a deletion
# event, (it looks weird) so clear the table/dropdown highlights now
#
self.view().selectionModel().setCurrentIndex(
QtCore.QModelIndex(),
QtCore.QItemSelectionModel.ClearAndSelect
)
#
# the deletion of an entry will shift all the entries beneath it up
# by one. in this case, it is important we refresh the selection index
# to reflect the director so that it stays correct.
#
self._refresh_selection()
def _ui_selection_changed(self, row):
"""
Handle selection change of coverage combobox.
"""
# convert the combobox row index into a QModelIndex
index = self.model().index(row, 0)
# using the true index, lookup the coverage name for this selection
coverage_name = self.model().data(index, QtCore.Qt.UserRole)
# pass the user selection onto the director to change loaded coverage
self._director.select_coverage(coverage_name)
#--------------------------------------------------------------------------
# Refresh
#--------------------------------------------------------------------------
def refresh(self):
"""
Public refresh of the coverage combobox.
"""
self._internal_refresh()
@disassembler.execute_ui
def refresh_theme(self):
"""
Refresh UI facing elements to reflect the current theme.
"""
palette = self._director.palette
self.view().refresh_theme()
# configure the combobox's top row / visible dropdown
self.lineEdit().setStyleSheet(
"QLineEdit { "
" border: none;"
" padding: 0 0 0 2ex;"
" margin: 0;"
" background-color: %s;" % palette.combobox_background.name() +
"}"
)
# style the combobox dropdown
self.setStyleSheet(
"QComboBox {"
" color: %s;" % palette.combobox_text.name() +
" border: 1px solid %s;" % palette.combobox_border.name() +
" padding: 0;"
"} "
"QComboBox:hover, QComboBox:focus {"
" border: 1px solid %s;" % palette.combobox_border_focus.name() +
"}"
)
@disassembler.execute_ui
def _internal_refresh(self):
"""
Internal refresh of the coverage combobox.
"""
# refresh the comobobox internals
self.model().refresh()
self.view().refresh()
#
# now that the comobobox is fully up to date, select the item index
# that matches the active coverage as per the director
#
self._refresh_selection()
def _refresh_selection(self):
"""
Refresh the coverage combobox selection.
"""
# NOTE: we block any index change signals to stop unnecessary churn
self.blockSignals(True)
new_index = self.findData(self._director.coverage_name)
self.setCurrentIndex(new_index)
self.lineEdit().home(False)
self.blockSignals(False)
#------------------------------------------------------------------------------
# Coverage ComboBox - TableView
#------------------------------------------------------------------------------
class CoverageComboBoxView(QtWidgets.QTableView):
"""
The (internal) table view used for the Coverage ComboBox dropdown.
"""
def __init__(self, model, parent=None):
super(CoverageComboBoxView, self).__init__(parent)
self.setObjectName(self.__class__.__name__)
self._combobox = weakref.proxy(parent)
self._timer = None
# install the given data model into the table view
self.setModel(model)
# initialize UI elements
self._ui_init()
self.refresh_theme()
#--------------------------------------------------------------------------
# QTableView Overloads
#--------------------------------------------------------------------------
def showEvent(self, e):
"""
Show the QComboBox dropdown/popup.
"""
#
# the next line of code will prevent the combobox 'head' from getting
# any mouse actions now that the popup/dropdown is visible.
#
# this is pretty aggressive, but it will allow the user to 'collapse'
# the combobox dropdown while it is in an expanded state by simply
# clicking the combobox head as one can do to expand it.
#
# the reason this dirty trick is able to simulate a 'collapsing click'
# is because the user clicks 'outside' the popup/dropdown which
# automatically closes it. if the click was on the combobox head, it
# is simply ignored because we set this attribute!
#
# when the popup is closing, we undo this action in hideEvent().
#
# we have to use this workaround because we are using an 'editable' Qt
# combobox which behaves differently to clicks than a normal combobox.
#
# NOTE: we have to do this here in the tableview because the combobox's
# showPopup() and hidePopup() do not always trigger symmetrically.
#
# for example, hidePopup() was not being triggered when focus was lost
# via virutal desktop switch, and other external focus changes. this
# is really bad, because the combobox would get stuck *closed* as it
# was never re-enabled for mouse events
#
self._combobox.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents)
def hideEvent(self, e):
"""
Hide the QComboBox dropdown/popup.
"""
#
# the combobox popup is now hidden / collapsed. the combobox head needs
# to be re-enlightened to direct mouse clicks (eg, to expand it). this
# undos the setAttribute action in showPopup() above.
#
# if the coverage combobox is *not* visible, the coverage window is
# probably being closed / deleted. but just in case, we should attempt
# to restore the combobox's ability to accept clicks before bailing.
#
# this fixes a bug / Qt warning first printed in IDA 7.4 where 'self'
# (the comobobox) would be deleted by the time the 100ms timer in the
# 'normal' case fires below
#
if not self._combobox.isVisible():
self._combobox.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents, False)
return
#
# in the more normal case, the comobobox is simply being collapsed
# by the user clicking it, or clicking away from it.
#
# we use a short timer of 100ms to ensure the 'hiding' of the dropdown
# and its associated click are processed first. aftwards, it is safe to
# begin accepting clicks again.
#
self._timer = QtCore.QTimer.singleShot(100, self.__hidePopup_setattr)
def __hidePopup_setattr(self):
self._combobox.setAttribute(QtCore.Qt.WA_TransparentForMouseEvents, False)
def leaveEvent(self, e):
"""
Overload the mouse leave event.
"""
#
# this code mitigates a bug (feature?) where the last hovered index
# of the table view was retaining its MouseOver flag internally. This
# was keeping my 'X' icons highlighted if the mouse cursor left the
# table while touching one of these cells last.
#
# we basically send a fake 'Hover Event' to the table viewport at an
# invalid position so table clears any remaining hover flags.
#
event = QtGui.QHoverEvent(QtCore.QEvent.HoverLeave, QtCore.QPoint(-1,-1), QtCore.QPoint(-1,-1))
QtWidgets.QApplication.sendEvent(self.viewport(), event)
#--------------------------------------------------------------------------
# Initialization - UI
#--------------------------------------------------------------------------
def _ui_init(self):
"""
Initialize UI elements.
"""
# initialize a monospace font to use with our widget(s)
self._font = MonospaceFont()
self._font.setPointSizeF(normalize_to_dpi(10))
self._font_metrics = QtGui.QFontMetricsF(self._font)
self.setFont(self._font)
# hide dropdown table headers, and default grid
self.horizontalHeader().setVisible(False)
self.verticalHeader().setVisible(False)
self.setShowGrid(False)
# let Qt automatically elide (...) long row text (coverage names)
self.resizeColumnToContents(0)
self.setTextElideMode(QtCore.Qt.ElideRight)
self.setWordWrap(False)
# more code-friendly, readable aliases
vh = self.verticalHeader()
hh = self.horizontalHeader()
#
# - set the coverage name column to be stretchy and as tall as the text
# - make the 'X' icon column fixed width
#
hh.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
hh.setSectionResizeMode(1, QtWidgets.QHeaderView.Fixed)
vh.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
hh.setMinimumSectionSize(0)
vh.setMinimumSectionSize(0)
# get the column width hint from the model for the 'X' delete column
icon_column_width = self.model().headerData(
COLUMN_DELETE,
QtCore.Qt.Horizontal,
QtCore.Qt.SizeHintRole
)
# set the 'X' delete icon column width to a fixed size based on the hint
hh.resizeSection(COLUMN_DELETE, icon_column_width)
# install a delegate to do some custom painting against the combobox
self.setItemDelegate(ComboBoxDelegate(self))
#--------------------------------------------------------------------------
# Refresh
#--------------------------------------------------------------------------
def refresh(self):
"""
Refresh the coverage combobox list order.
"""
model = self.model() # alias for readability
# merge the 'special' entries up until a seperator is found
for row in xrange(model.rowCount()):
#
# if this row is not a user defined entry, we want to merge ('span')
# its cells so there is no 'X' delete button column shown for it.
#
# this should apply to special rows such as the 'Hot Shell',
# 'Aggregate', or the 'separator' indexes
#
if not model.data(model.index(row, 1), QtCore.Qt.DecorationRole):
self.setSpan(row, 0, 1, model.columnCount())
# this is a user entry, ensure there is no span present (clear it)
else:
self.setSpan(row, 0, 0, model.columnCount())
@disassembler.execute_ui
def refresh_theme(self):
"""
Refresh UI facing elements to reflect the current theme.
"""
palette = self.model()._director.palette
self.setStyleSheet(
"QTableView {"
" background-color: %s;" % palette.combobox_background.name() +
" color: %s;" % palette.combobox_text.name() +
" margin: 0; outline: none;"
" border: 1px solid %s; " % palette.shell_border.name() +
"} "
"QTableView::item { " +
" padding: 0.5ex; border: 0; "
"} "
"QTableView::item:focus { " +
" background-color: %s; " % palette.combobox_selection_background.name() +
" color: %s; " % palette.combobox_selection_text.name() +
"} "
)
#------------------------------------------------------------------------------
# Coverage ComboBox - TableModel
#------------------------------------------------------------------------------
class CoverageComboBoxModel(QtCore.QAbstractTableModel):
"""
The (internal) table model used for the Coverage ComboBox dropdown.
"""
def __init__(self, director, parent=None):
super(CoverageComboBoxModel, self).__init__(parent)
self.setObjectName(self.__class__.__name__)
self._director = director
# our internal model
self._entries = []
self._seperator_index = 0
# initialize a monospace font to use with our widget(s)
self._font = MonospaceFont()
self._font.setPointSizeF(normalize_to_dpi(10))
self._font_metrics = QtGui.QFontMetricsF(self._font)
# load the raw 'X' delete icon from disk
delete_icon = QtGui.QPixmap(plugin_resource("icons/delete_coverage.png"))
# compute the appropriate size for the deletion icon
icon_height = self._font_metrics.height()*0.75
icon_width = icon_height
# scale the icon as appropriate (very likely scaling it down)
self._delete_icon = delete_icon.scaled(
icon_width,
icon_height,
QtCore.Qt.KeepAspectRatio,
QtCore.Qt.SmoothTransformation
)
# register for cues from the director
self._director.coverage_created(self.refresh)
self._director.coverage_deleted(self.refresh)
#--------------------------------------------------------------------------
# QAbstractTableModel Overloads
#--------------------------------------------------------------------------
def rowCount(self, parent=QtCore.QModelIndex()):
"""
The number of dropdown rows.
"""
return len(self._entries)
def columnCount(self, parent=QtCore.QModelIndex()):
"""
The nubmer of dropdown columns.
| column[0] | column[1]
+---------------------------+--------------------
| detailed coverage string1 | 'X' (delete icon)
| detailed coverage string2 | 'X' (delete icon)
...
"""
return 2
def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
"""
Define the properties of the the table rows & columns.
"""
# table row property request
if orientation == QtCore.Qt.Vertical:
# row height size hint request
if role == QtCore.Qt.SizeHintRole:
# the separator 'row' has a special, 'thinner' row size
if section == self._seperator_index:
return SEPARATOR_HEIGHT
# all other rows should be at least as tall as their text
else:
return self._font_metrics.height()
# table column property request
elif orientation == QtCore.Qt.Horizontal:
# column width size hint request
if role == QtCore.Qt.SizeHintRole:
#
# the column holding the 'X' delete icon should be small
# and fixed width, therefore we are explicit in specifying
# our own size hint for it.
#
# note that the icon size is used to hint the column width,
# but multiplied by two. this is because we want the 'X'
# icon to float and have some padding in its column.
#
if section == COLUMN_DELETE:
return self._delete_icon.size().width() * 2
# unhandled request, nothing to do
return None
def data(self, index, role=QtCore.Qt.DisplayRole):
"""
Define how Qt should access the underlying model data.
"""
# sanity check the given index
if not index.isValid() or \
not (index.row() < self.rowCount()) or \
not (index.column() < self.columnCount()):
return None
# font format request
if role == QtCore.Qt.FontRole:
return self._font
# text alignment request
elif role == QtCore.Qt.TextAlignmentRole:
return QtCore.Qt.AlignVCenter | QtCore.Qt.AlignLeft
# combobox header, padded with " " to account for dropdown arrow overlap
elif role == QtCore.Qt.EditRole:
if index.column() == COLUMN_COVERAGE_STRING and index.row() != self._seperator_index:
return self._director.get_coverage_string(self._entries[index.row()]) + " "
# data display request
elif role == QtCore.Qt.DisplayRole:
if index.column() == COLUMN_COVERAGE_STRING and index.row() != self._seperator_index:
return self._director.get_coverage_string(self._entries[index.row()])
# tooltip
elif role == QtCore.Qt.ToolTipRole:
if index.column() == COLUMN_COVERAGE_STRING and index.row() != self._seperator_index:
coverage = self._director.get_coverage(self._entries[index.row()])
return coverage.filepath if coverage.filepath else ""
elif index.column() == COLUMN_DELETE:
return "Delete loaded coverage"
# icon display request
elif role == QtCore.Qt.DecorationRole:
# the icon request is for the 'X' column
if index.column() == COLUMN_DELETE:
#
# if the coverage entry is below the separator, it is a user
# loaded coverage and should always be deletable
#
if index.row() > self._seperator_index:
return self._delete_icon
#
# as a special case, we allow the aggregate to have a clear
# icon, which will clear all user loaded coverages
#
elif self._entries[index.row()] == "Aggregate":
return self._delete_icon
# entry type request
elif role == QtCore.Qt.AccessibleDescriptionRole:
#
# if the entry is ABOVE the separator index, it's a 'special'
# entry, eg 'Hot Shell', 'New Composition', 'Aggregate'
#
if index.row() < self._seperator_index:
return ENTRY_SPECIAL
#
# the entry IS the separator index
#
elif index.row() == self._seperator_index:
return SEPARATOR
#
# if the entry is BELOW the separator index, it's a 'user'
# entry, eg loaded coverage files, compositions, etc
#
else:
return ENTRY_USER
# entry coverage_name request
elif role == QtCore.Qt.UserRole:
return self._entries[index.row()]
# unhandeled request, nothing to do
return None
def flags(self, index):
"""
Item flags for the given entry index.
"""
# the 'X' column is ENABLED, but not technically selectable
if index.column() == COLUMN_DELETE:
return QtCore.Qt.ItemIsEnabled
# the separator should not be interactive in *any* way
if index.row() == self._seperator_index:
return QtCore.Qt.NoItemFlags
# unhandeled request, pass through
return super(CoverageComboBoxModel, self).flags(index)
#--------------------------------------------------------------------------
# Refresh
#--------------------------------------------------------------------------
def refresh(self):
"""
Refresh the coverage combobox model data.
"""
# extract all the names from the director with a shorthand symbol
with_shorthand = []
for name in self._director.coverage_names:
if self._director.get_shorthand(name):
with_shorthand.append(name)
# re-populate the model entries
self._entries = []
self._entries += list(self._director.special_names)
self._entries += [SEPARATOR]
self._entries += with_shorthand
# save the index of the separator for easy reference
self._seperator_index = self._entries.index(SEPARATOR)
# notify any listeners that the model layout may have changed
self.layoutChanged.emit()
#------------------------------------------------------------------------------
# Coverage ComboBox - Painting Delegate
#------------------------------------------------------------------------------
class ComboBoxDelegate(QtWidgets.QStyledItemDelegate):
"""
Coverage ComboBox Painting Delegate
Painting delegates can be used to augment the painting of a given
widget or its items. In this case, we use it to customize the
dropdown table in the Coverage ComboBox a bit more to our liking.
"""
def __init__(self, parent):
super(ComboBoxDelegate, self).__init__(parent)
# painting property definitions
self._grid_color = parent.model()._director.palette.shell_border
def sizeHint(self, option, index):
"""
Augmented entry sizeHint.
"""
if index.data(QtCore.Qt.AccessibleDescriptionRole) == SEPARATOR:
return QtCore.QSize(1, SEPARATOR_HEIGHT)
return super(ComboBoxDelegate, self).sizeHint(option, index)
def paint(self, painter, option, index):
"""
Augmented entry painting.
"""
# custom paint the 'grid line' beneath each coverage entry
if index.data(QtCore.Qt.AccessibleDescriptionRole) == ENTRY_USER:
painter.save()
painter.setPen(self._grid_color)
final_entry = (index.sibling(index.row()+1, 0).row() == -1)
# draw the grid line beneath the current row (a coverage entry)
tweak = QtCore.QPoint(0, 1) # 1px tweak provides better spacing
if not final_entry:
painter.drawLine(
option.rect.bottomLeft() + tweak,
option.rect.bottomRight() + tweak
)
#
# now we will re-draw the grid line *above* the current entry,
# fixing a minor graphical bug where grid lines could disappear
# after hovering over a row / entry
#
previous = index.sibling(index.row()-1, 0)
painter.drawLine(
option.rect.topLeft(),
option.rect.topRight()
)
painter.restore()
# custom paint the 'X' icon where applicable
if index.data(QtCore.Qt.DecorationRole):
# get the icon data from the model
pixmap = index.data(QtCore.Qt.DecorationRole)
# center the draw rect in the middle of the 'X' column cell
destination_rect = pixmap.rect()
destination_rect.moveCenter(option.rect.center())
# augment the icon pixmap to be grayed out (disabled) or colored
# based on the mouse hover status of this index
if not (option.state & QtWidgets.QStyle.State_MouseOver):
pixmap = QtWidgets.QApplication.style().generatedIconPixmap(
QtGui.QIcon.Disabled,
pixmap,
QtWidgets.QStyleOption()
)
# draw the icon to the column
painter.drawPixmap(destination_rect, pixmap)
return
# custom paint the separator entry between special & normal coverage
if index.data(QtCore.Qt.AccessibleDescriptionRole) == SEPARATOR:
painter.save()
painter.setPen(self._grid_color)
painter.drawRect(
option.rect
)
painter.restore()
# nothing else to paint for the separator entry
return
# pass through to the standard painting
super(ComboBoxDelegate, self).paint(painter, option, index)
|
scripts/bleu_over_length.py | anoidgit/zero | 111 | 11100445 | <filename>scripts/bleu_over_length.py
# coding=utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import math
import argparse
from collections import Counter
def closest_length(candidate, references):
clen = len(candidate)
closest_diff = 9999
closest_len = 9999
for reference in references:
rlen = len(reference)
diff = abs(rlen - clen)
if diff < closest_diff:
closest_diff = diff
closest_len = rlen
elif diff == closest_diff:
closest_len = rlen if rlen < closest_len else closest_len
return closest_len
def shortest_length(references):
return min([len(ref) for ref in references])
def modified_precision(candidate, references, n):
tngrams = len(candidate) + 1 - n
counts = Counter([tuple(candidate[i:i+n]) for i in range(tngrams)])
if len(counts) == 0:
return 0, 0
max_counts = {}
for reference in references:
rngrams = len(reference) + 1 - n
ngrams = [tuple(reference[i:i+n]) for i in range(rngrams)]
ref_counts = Counter(ngrams)
for ngram in counts:
mcount = 0 if ngram not in max_counts else max_counts[ngram]
rcount = 0 if ngram not in ref_counts else ref_counts[ngram]
max_counts[ngram] = max(mcount, rcount)
clipped_counts = {}
for ngram, count in counts.items():
clipped_counts[ngram] = min(count, max_counts[ngram])
return float(sum(clipped_counts.values())), float(sum(counts.values()))
def brevity_penalty(trans, refs, mode="closest"):
bp_c = 0.0
bp_r = 0.0
for candidate, references in zip(trans, refs):
bp_c += len(candidate)
if mode == "shortest":
bp_r += shortest_length(references)
else:
bp_r += closest_length(candidate, references)
# Prevent zero divide
bp_c = bp_c or 1.0
return math.exp(min(0, 1.0 - bp_r / bp_c))
def bleu(trans, refs, bp="closest", smooth=False, n=4, weights=None):
p_norm = [0 for _ in range(n)]
p_denorm = [0 for _ in range(n)]
for candidate, references in zip(trans, refs):
for i in range(n):
ccount, tcount = modified_precision(candidate, references, i + 1)
p_norm[i] += ccount
p_denorm[i] += tcount
bleu_n = [0 for _ in range(n)]
for i in range(n):
# add one smoothing
if smooth and i > 0:
p_norm[i] += 1
p_denorm[i] += 1
if p_norm[i] == 0 or p_denorm[i] == 0:
bleu_n[i] = -9999
else:
bleu_n[i] = math.log(float(p_norm[i]) / float(p_denorm[i]))
if weights:
if len(weights) != n:
raise ValueError("len(weights) != n: invalid weight number")
log_precision = sum([bleu_n[i] * weights[i] for i in range(n)])
else:
log_precision = sum(bleu_n) / float(n)
bp = brevity_penalty(trans, refs, bp)
score = bp * math.exp(log_precision)
return score
def read(f, lc=False):
with open(f, 'rU') as reader:
return [line.strip().split() if not lc else line.strip().lower().split()
for line in reader.readlines()]
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='BLEU score over source sentence length')
parser.add_argument('-lc', help='Lowercase, i.e case-insensitive setting', action='store_true')
parser.add_argument('-bp', help='Length penalty', default='closest', choices=['shortest', 'closest'])
parser.add_argument('-n', type=int, default=4, help="ngram-based BLEU")
parser.add_argument('-g', type=int, default=1, help="sentence groups for evaluation")
parser.add_argument('-source', type=str, required=True, help='The source file')
parser.add_argument('-candidate', type=str, required=True, help='The candidate translation generated by MT system')
parser.add_argument('-reference', type=str, nargs='+', required=True,
help='The references like reference or reference0, reference1, ...')
args = parser.parse_args()
cand = args.candidate
refs = args.reference
src = args.source
src_sentences = read(src, args.lc)
cand_sentences = read(cand, args.lc)
refs_sentences = [read(ref, args.lc) for ref in refs]
assert len(cand_sentences) == len(refs_sentences[0]), \
'ERROR: the length of candidate and reference must be the same.'
refs_sentences = list(zip(*refs_sentences))
sorted_candidate_sentences = sorted(zip(src_sentences, cand_sentences), key=lambda x: len(x[0]))
sorted_reference_sentences = sorted(zip(src_sentences, refs_sentences), key=lambda x: len(x[0]))
sorted_source_sentences = [v[0] for v in sorted_candidate_sentences]
sorted_candidate_sentences = [v[1] for v in sorted_candidate_sentences]
sorted_reference_sentences = [v[1] for v in sorted_reference_sentences]
groups = args.g
elements_per_group = len(sorted_source_sentences) // groups
scores = []
for gidx in range(groups):
group_candidate = sorted_candidate_sentences[gidx * elements_per_group: (gidx + 1) * elements_per_group]
group_reference = sorted_reference_sentences[gidx * elements_per_group: (gidx + 1) * elements_per_group]
group_source = sorted_source_sentences[gidx * elements_per_group: (gidx + 1) * elements_per_group]
group_average_source = float(sum([len(v) for v in group_source])) / float(len(group_source))
bleu_score = bleu(group_candidate, group_reference, bp=args.bp, n=args.n)
print("Group Idx {} Avg Source Lenngth {} BLEU Score {}".format(gidx, group_average_source, bleu_score))
scores.append((group_average_source, bleu_score))
print('AvgLength: [{}]'.format(','.join([str(s[0]) for s in scores])))
print('BLEU Score: [{}]'.format(','.join([str(s[1]) for s in scores])))
|
setup.py | davidgodzsak/opentype-svg | 166 | 11100485 | from setuptools import setup
with open("README.md", "r") as fh:
long_description = fh.read()
setup(
name="opentypesvg",
use_scm_version={'write_to': 'lib/opentypesvg/__version__.py'},
setup_requires=["setuptools_scm"],
author="<NAME>",
author_email="<EMAIL>",
description="Tools for making OpenType-SVG fonts",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/adobe-type-tools/opentype-svg",
license="MIT",
platforms=["Any"],
package_dir={'': 'lib'},
packages=['opentypesvg'],
python_requires='>=3.6',
install_requires=['fontTools[woff]>=3.1.0'],
entry_points={
'console_scripts': [
"addsvg = opentypesvg.addsvg:main",
"dumpsvg = opentypesvg.dumpsvg:main",
"fonts2svg = opentypesvg.fonts2svg:main",
]
},
)
|
samza-test/src/main/python/templates.py | xiefan46/samza | 860 | 11100503 | # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from contextlib import nested
from jinja2 import Template
def render_config(template_location, rendered_location, properties):
"""
A method for rendering simple key/value configs into a template. Uses Jinja2
style templating.
param: template_location -- File path of the input Jinja2 template.
param: rendered_location -- File path where rendered output should be saved.
param: properties -- A dictionary of key/value pairs to be passed to the
template with the accessor name 'properties'.
"""
with nested(open(template_location, 'r'), open(rendered_location, 'w')) as (input, output):
template = Template(input.read())
rendered = template.render(properties=properties)
output.write(rendered)
|
doc/src/modules/mpmath/plots/ber.py | shipci/sympy | 319 | 11100508 | # Kelvin functions ber_n(x) and bei_n(x) on the real line for n=0,2
f0 = lambda x: ber(0,x)
f1 = lambda x: bei(0,x)
f2 = lambda x: ber(2,x)
f3 = lambda x: bei(2,x)
plot([f0,f1,f2,f3],[0,10],[-10,10]) |
wsi/bin/train.py | mingrui/NCRF | 734 | 11100522 | import sys
import os
import argparse
import logging
import json
import time
import torch
from torch.utils.data import DataLoader
from torch.autograd import Variable
from torch.nn import BCEWithLogitsLoss, DataParallel
from torch.optim import SGD
from tensorboardX import SummaryWriter
sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../')
torch.manual_seed(0)
torch.cuda.manual_seed_all(0)
from wsi.data.image_producer import GridImageDataset # noqa
from wsi.model import MODELS # noqa
parser = argparse.ArgumentParser(description='Train model')
parser.add_argument('cfg_path', default=None, metavar='CFG_PATH', type=str,
help='Path to the config file in json format')
parser.add_argument('save_path', default=None, metavar='SAVE_PATH', type=str,
help='Path to the saved models')
parser.add_argument('--num_workers', default=2, type=int, help='number of'
' workers for each data loader, default 2.')
parser.add_argument('--device_ids', default='0', type=str, help='comma'
' separated indices of GPU to use, e.g. 0,1 for using GPU_0'
' and GPU_1, default 0.')
def train_epoch(summary, summary_writer, cfg, model, loss_fn, optimizer,
dataloader_tumor, dataloader_normal):
model.train()
steps = len(dataloader_tumor)
batch_size = dataloader_tumor.batch_size
grid_size = dataloader_tumor.dataset._grid_size
dataiter_tumor = iter(dataloader_tumor)
dataiter_normal = iter(dataloader_normal)
time_now = time.time()
for step in range(steps):
data_tumor, target_tumor = next(dataiter_tumor)
data_tumor = Variable(data_tumor.cuda(async=True))
target_tumor = Variable(target_tumor.cuda(async=True))
data_normal, target_normal = next(dataiter_normal)
data_normal = Variable(data_normal.cuda(async=True))
target_normal = Variable(target_normal.cuda(async=True))
idx_rand = Variable(
torch.randperm(batch_size * 2).cuda(async=True))
data = torch.cat([data_tumor, data_normal])[idx_rand]
target = torch.cat([target_tumor, target_normal])[idx_rand]
output = model(data)
loss = loss_fn(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
probs = output.sigmoid()
predicts = (probs >= 0.5).type(torch.cuda.FloatTensor)
acc_data = (predicts == target).type(
torch.cuda.FloatTensor).sum().data[0] * 1.0 / (
batch_size * grid_size * 2)
loss_data = loss.data[0]
time_spent = time.time() - time_now
time_now = time.time()
logging.info(
'{}, Epoch : {}, Step : {}, Training Loss : {:.5f}, '
'Training Acc : {:.3f}, Run Time : {:.2f}'
.format(
time.strftime("%Y-%m-%d %H:%M:%S"), summary['epoch'] + 1,
summary['step'] + 1, loss_data, acc_data, time_spent))
summary['step'] += 1
if summary['step'] % cfg['log_every'] == 0:
summary_writer.add_scalar('train/loss', loss_data, summary['step'])
summary_writer.add_scalar('train/acc', acc_data, summary['step'])
summary['epoch'] += 1
return summary
def valid_epoch(summary, cfg, model, loss_fn,
dataloader_tumor, dataloader_normal):
model.eval()
steps = len(dataloader_tumor)
batch_size = dataloader_tumor.batch_size
grid_size = dataloader_tumor.dataset._grid_size
dataiter_tumor = iter(dataloader_tumor)
dataiter_normal = iter(dataloader_normal)
loss_sum = 0
acc_sum = 0
for step in range(steps):
data_tumor, target_tumor = next(dataiter_tumor)
data_tumor = Variable(data_tumor.cuda(async=True), volatile=True)
target_tumor = Variable(target_tumor.cuda(async=True))
data_normal, target_normal = next(dataiter_normal)
data_normal = Variable(data_normal.cuda(async=True), volatile=True)
target_normal = Variable(target_normal.cuda(async=True))
data = torch.cat([data_tumor, data_normal])
target = torch.cat([target_tumor, target_normal])
output = model(data)
loss = loss_fn(output, target)
probs = output.sigmoid()
predicts = (probs >= 0.5).type(torch.cuda.FloatTensor)
acc_data = (predicts == target).type(
torch.cuda.FloatTensor).sum().data[0] * 1.0 / (
batch_size * grid_size * 2)
loss_data = loss.data[0]
loss_sum += loss_data
acc_sum += acc_data
summary['loss'] = loss_sum / steps
summary['acc'] = acc_sum / steps
return summary
def run(args):
with open(args.cfg_path) as f:
cfg = json.load(f)
if not os.path.exists(args.save_path):
os.mkdir(args.save_path)
with open(os.path.join(args.save_path, 'cfg.json'), 'w') as f:
json.dump(cfg, f, indent=1)
os.environ["CUDA_VISIBLE_DEVICES"] = args.device_ids
num_GPU = len(args.device_ids.split(','))
batch_size_train = cfg['batch_size'] * num_GPU
batch_size_valid = cfg['batch_size'] * num_GPU * 2
num_workers = args.num_workers * num_GPU
if cfg['image_size'] % cfg['patch_size'] != 0:
raise Exception('Image size / patch size != 0 : {} / {}'.
format(cfg['image_size'], cfg['patch_size']))
patch_per_side = cfg['image_size'] // cfg['patch_size']
grid_size = patch_per_side * patch_per_side
model = MODELS[cfg['model']](num_nodes=grid_size, use_crf=cfg['use_crf'])
model = DataParallel(model, device_ids=None)
model = model.cuda()
loss_fn = BCEWithLogitsLoss().cuda()
optimizer = SGD(model.parameters(), lr=cfg['lr'], momentum=cfg['momentum'])
dataset_tumor_train = GridImageDataset(cfg['data_path_tumor_train'],
cfg['json_path_train'],
cfg['image_size'],
cfg['patch_size'],
crop_size=cfg['crop_size'])
dataset_normal_train = GridImageDataset(cfg['data_path_normal_train'],
cfg['json_path_train'],
cfg['image_size'],
cfg['patch_size'],
crop_size=cfg['crop_size'])
dataset_tumor_valid = GridImageDataset(cfg['data_path_tumor_valid'],
cfg['json_path_valid'],
cfg['image_size'],
cfg['patch_size'],
crop_size=cfg['crop_size'])
dataset_normal_valid = GridImageDataset(cfg['data_path_normal_valid'],
cfg['json_path_valid'],
cfg['image_size'],
cfg['patch_size'],
crop_size=cfg['crop_size'])
dataloader_tumor_train = DataLoader(dataset_tumor_train,
batch_size=batch_size_train,
num_workers=num_workers)
dataloader_normal_train = DataLoader(dataset_normal_train,
batch_size=batch_size_train,
num_workers=num_workers)
dataloader_tumor_valid = DataLoader(dataset_tumor_valid,
batch_size=batch_size_valid,
num_workers=num_workers)
dataloader_normal_valid = DataLoader(dataset_normal_valid,
batch_size=batch_size_valid,
num_workers=num_workers)
summary_train = {'epoch': 0, 'step': 0}
summary_valid = {'loss': float('inf'), 'acc': 0}
summary_writer = SummaryWriter(args.save_path)
loss_valid_best = float('inf')
for epoch in range(cfg['epoch']):
summary_train = train_epoch(summary_train, summary_writer, cfg, model,
loss_fn, optimizer,
dataloader_tumor_train,
dataloader_normal_train)
torch.save({'epoch': summary_train['epoch'],
'step': summary_train['step'],
'state_dict': model.module.state_dict()},
os.path.join(args.save_path, 'train.ckpt'))
time_now = time.time()
summary_valid = valid_epoch(summary_valid, cfg, model, loss_fn,
dataloader_tumor_valid,
dataloader_normal_valid)
time_spent = time.time() - time_now
logging.info(
'{}, Epoch : {}, Step : {}, Validation Loss : {:.5f}, '
'Validation Acc : {:.3f}, Run Time : {:.2f}'
.format(
time.strftime("%Y-%m-%d %H:%M:%S"), summary_train['epoch'],
summary_train['step'], summary_valid['loss'],
summary_valid['acc'], time_spent))
summary_writer.add_scalar(
'valid/loss', summary_valid['loss'], summary_train['step'])
summary_writer.add_scalar(
'valid/acc', summary_valid['acc'], summary_train['step'])
if summary_valid['loss'] < loss_valid_best:
loss_valid_best = summary_valid['loss']
torch.save({'epoch': summary_train['epoch'],
'step': summary_train['step'],
'state_dict': model.module.state_dict()},
os.path.join(args.save_path, 'best.ckpt'))
summary_writer.close()
def main():
logging.basicConfig(level=logging.INFO)
args = parser.parse_args()
run(args)
if __name__ == '__main__':
main()
|
lib/plugins/rssfeed.py | ikstream/Zeus-Scanner | 841 | 11100526 | import re
__product__ = "RSS Feed"
__description__ = (
"RSS (Rich Site Summary) is a type of web feed which allows "
"users to access updates to online content in a standardized, "
"computer-readable format"
)
def search(html, **kwargs):
html = str(html)
plugin_detection_schema = (
re.compile(r"type.[\'\"]?application/rss.xml[\'\"]?", re.I),
re.compile(r"title.[\'\"]?rss.feed[\'\"]?", re.I)
)
for plugin in plugin_detection_schema:
if plugin.search(html) is not None:
return True
|
release.py | ashishb/adb-enhanced | 910 | 11100531 | <filename>release.py<gh_stars>100-1000
#!/usr/bin/env python3
import os
import subprocess
import sys
import docopt
_DIR_OF_THIS_SCRIPT = os.path.split(__file__)[0]
_VERSION_FILE_NAME = 'version.txt'
_VERSION_FILE_PATH = os.path.join(
_DIR_OF_THIS_SCRIPT, 'adbe', _VERSION_FILE_NAME)
_README_FILE_NAME = os.path.join('docs', 'README.rst')
_TEST_PYPI_URL = 'https://test.pypi.org/legacy/'
_PROJECT_NAME = 'adb-enhanced'
_SRC_FILE_NAMES = [
'abe.jar',
'apksigner.jar',
'adb_enhanced.py',
'adb_helper.py',
'asyncio_helper.py',
'main.py',
'output_helper.py',
'version.txt',
]
def _get_version():
with open(_VERSION_FILE_PATH, 'r') as file_handle:
version = file_handle.read().strip()
return version
def _set_version(version):
if not version or not version.strip():
raise Exception('version cannot be empty')
with open(_VERSION_FILE_PATH, 'w') as file_handle:
file_handle.write('%s\n' % version)
def _prompt_user_to_update_version(version_file):
current_version = _get_version()
print('Current version is %s' % current_version)
new_version = input("Enter new version: ")
_set_version(new_version or current_version)
with open(version_file, 'w') as file_handle:
file_handle.write(new_version)
def _push_new_release_to_git(version_file):
with open(version_file) as file_handle:
version = file_handle.read()
cmds = [
'git add %s' % version_file,
'git commit -m "Setup release %s"' % version,
'git tag %s' % version,
'git push --tags',
]
for cmd in cmds:
_run_cmd_or_fail(cmd)
def _publish_package_to_pypi(testing_release=False):
if testing_release:
_run_cmd_or_fail(
'python3 -m twine upload --repository-url %s dist/*' % _TEST_PYPI_URL)
print('Few mins later, check https://test.pypi.org/project/%s/#history to confirm upload' %
_PROJECT_NAME)
else:
_run_cmd_or_fail('python3 -m twine upload dist/*')
print('Few mins later, check https://pypi.org/project/%s/#history to confirm upload' %
_PROJECT_NAME)
def _run_cmd_or_fail(cmd):
print('Executing \"%s\"...' % cmd)
with subprocess.Popen(cmd, shell=True, stdout=None, stderr=None) as process:
process.communicate()
if process.returncode == 0:
print('Successfully executed \"%s\"' % cmd)
else:
print('Failed to execute \"%s\"' % cmd)
sys.exit(1)
def _publish_release(testing_release=False):
version_file = os.path.join('adbe', 'version.txt')
_prompt_user_to_update_version(version_file)
_run_cmd_or_fail('make build')
_push_new_release_to_git(version_file)
_publish_package_to_pypi(testing_release)
# List of things which this release tool does as of today.
USAGE_STRING = """
Release script for %s
Usage:
release.py test release
release.py production release
""" % _PROJECT_NAME
def _using_python2():
return sys.version_info < (3, 0)
def main():
if _using_python2():
print('Python 2 is not supported, only Python 3 is supported')
sys.exit(1)
args = docopt.docopt(USAGE_STRING, version='1.0')
if args['test'] and args['release']:
_publish_release(testing_release=True)
elif args['production'] and args['release']:
_publish_release(testing_release=False)
else:
print('Unexpected command')
sys.exit(1)
if __name__ == '__main__':
main()
|
blockchain-workbench/rest-api-samples/python/swagger_client/api/connections_api.py | chaosmail/blockchain | 738 | 11100533 | # coding: utf-8
"""
Azure Blockchain Workbench REST API
The Azure Blockchain Workbench REST API is a Workbench extensibility point, which allows developers to create and manage blockchain applications, manage users and organizations within a consortium, integrate blockchain applications into services and platforms, perform transactions on a blockchain, and retrieve transactional and contract data from a blockchain. # noqa: E501
OpenAPI spec version: v1
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
from __future__ import absolute_import
import re # noqa: F401
# python 2 and python 3 compatibility library
import six
from swagger_client.api_client import ApiClient
class ConnectionsApi(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
Ref: https://github.com/swagger-api/swagger-codegen
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def block_get(self, connection_id, block_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the block matching a specific block ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.block_get(connection_id, block_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The connectionId of the block (required)
:param int block_id: The id of the block (required)
:return: Block
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.block_get_with_http_info(connection_id, block_id, **kwargs) # noqa: E501
else:
(data) = self.block_get_with_http_info(connection_id, block_id, **kwargs) # noqa: E501
return data
def block_get_with_http_info(self, connection_id, block_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the block matching a specific block ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.block_get_with_http_info(connection_id, block_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The connectionId of the block (required)
:param int block_id: The id of the block (required)
:return: Block
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['connection_id', 'block_id'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method block_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'connection_id' is set
if ('connection_id' not in params or
params['connection_id'] is None):
raise ValueError("Missing the required parameter `connection_id` when calling `block_get`") # noqa: E501
# verify the required parameter 'block_id' is set
if ('block_id' not in params or
params['block_id'] is None):
raise ValueError("Missing the required parameter `block_id` when calling `block_get`") # noqa: E501
collection_formats = {}
path_params = {}
if 'connection_id' in params:
path_params['connectionId'] = params['connection_id'] # noqa: E501
if 'block_id' in params:
path_params['blockId'] = params['block_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections/{connectionId}/blocks/{blockId}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Block', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def blocks_get(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Lists the blocks for a connected blockchain network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.blocks_get(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: BlockList
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.blocks_get_with_http_info(connection_id, **kwargs) # noqa: E501
else:
(data) = self.blocks_get_with_http_info(connection_id, **kwargs) # noqa: E501
return data
def blocks_get_with_http_info(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Lists the blocks for a connected blockchain network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.blocks_get_with_http_info(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: BlockList
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['connection_id', 'top', 'skip'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method blocks_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'connection_id' is set
if ('connection_id' not in params or
params['connection_id'] is None):
raise ValueError("Missing the required parameter `connection_id` when calling `blocks_get`") # noqa: E501
collection_formats = {}
path_params = {}
if 'connection_id' in params:
path_params['connectionID'] = params['connection_id'] # noqa: E501
query_params = []
if 'top' in params:
query_params.append(('top', params['top'])) # noqa: E501
if 'skip' in params:
query_params.append(('skip', params['skip'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections/{connectionId}/blocks', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='BlockList', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def connection_get(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the connected blockchain network matching a specific chain instance ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.connection_get(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:return: Connection
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.connection_get_with_http_info(connection_id, **kwargs) # noqa: E501
else:
(data) = self.connection_get_with_http_info(connection_id, **kwargs) # noqa: E501
return data
def connection_get_with_http_info(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the connected blockchain network matching a specific chain instance ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.connection_get_with_http_info(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:return: Connection
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['connection_id'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method connection_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'connection_id' is set
if ('connection_id' not in params or
params['connection_id'] is None):
raise ValueError("Missing the required parameter `connection_id` when calling `connection_get`") # noqa: E501
collection_formats = {}
path_params = {}
if 'connection_id' in params:
path_params['connectionID'] = params['connection_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections/{connectionId}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Connection', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def connections_get(self, **kwargs): # noqa: E501
""" # noqa: E501
Lists the connected blockchain networks. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.connections_get(async=True)
>>> result = thread.get()
:param async bool
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: ConnectionList
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.connections_get_with_http_info(**kwargs) # noqa: E501
else:
(data) = self.connections_get_with_http_info(**kwargs) # noqa: E501
return data
def connections_get_with_http_info(self, **kwargs): # noqa: E501
""" # noqa: E501
Lists the connected blockchain networks. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.connections_get_with_http_info(async=True)
>>> result = thread.get()
:param async bool
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: ConnectionList
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['top', 'skip'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method connections_get" % key
)
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'top' in params:
query_params.append(('top', params['top'])) # noqa: E501
if 'skip' in params:
query_params.append(('skip', params['skip'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ConnectionList', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def transaction_get(self, connection_id, transaction_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the transaction matching a specific transaction ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.transaction_get(connection_id, transaction_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The connectionId of the transaction (required)
:param int transaction_id: The id of the transaction (required)
:return: Transaction
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.transaction_get_with_http_info(connection_id, transaction_id, **kwargs) # noqa: E501
else:
(data) = self.transaction_get_with_http_info(connection_id, transaction_id, **kwargs) # noqa: E501
return data
def transaction_get_with_http_info(self, connection_id, transaction_id, **kwargs): # noqa: E501
""" # noqa: E501
Gets the transaction matching a specific transaction ID. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.transaction_get_with_http_info(connection_id, transaction_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The connectionId of the transaction (required)
:param int transaction_id: The id of the transaction (required)
:return: Transaction
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['connection_id', 'transaction_id'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method transaction_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'connection_id' is set
if ('connection_id' not in params or
params['connection_id'] is None):
raise ValueError("Missing the required parameter `connection_id` when calling `transaction_get`") # noqa: E501
# verify the required parameter 'transaction_id' is set
if ('transaction_id' not in params or
params['transaction_id'] is None):
raise ValueError("Missing the required parameter `transaction_id` when calling `transaction_get`") # noqa: E501
collection_formats = {}
path_params = {}
if 'connection_id' in params:
path_params['connectionId'] = params['connection_id'] # noqa: E501
if 'transaction_id' in params:
path_params['transactionId'] = params['transaction_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections/{connectionId}/transactions/{transactionId}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Transaction', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
def transactions_get(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Lists the transactions for a connected blockchain network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.transactions_get(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: list[TransactionList]
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async'):
return self.transactions_get_with_http_info(connection_id, **kwargs) # noqa: E501
else:
(data) = self.transactions_get_with_http_info(connection_id, **kwargs) # noqa: E501
return data
def transactions_get_with_http_info(self, connection_id, **kwargs): # noqa: E501
""" # noqa: E501
Lists the transactions for a connected blockchain network. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async=True
>>> thread = api.transactions_get_with_http_info(connection_id, async=True)
>>> result = thread.get()
:param async bool
:param int connection_id: The id of the connection (required)
:param int top: The maximum number of items to return
:param int skip: The number of items to skip before returning
:return: list[TransactionList]
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['connection_id', 'top', 'skip'] # noqa: E501
all_params.append('async')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method transactions_get" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'connection_id' is set
if ('connection_id' not in params or
params['connection_id'] is None):
raise ValueError("Missing the required parameter `connection_id` when calling `transactions_get`") # noqa: E501
collection_formats = {}
path_params = {}
if 'connection_id' in params:
path_params['connectionId'] = params['connection_id'] # noqa: E501
query_params = []
if 'top' in params:
query_params.append(('top', params['top'])) # noqa: E501
if 'skip' in params:
query_params.append(('skip', params['skip'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = [] # noqa: E501
return self.api_client.call_api(
'/api/v1/ledgers/connections/{connectionId}/transactions', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[TransactionList]', # noqa: E501
auth_settings=auth_settings,
async=params.get('async'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats)
|
scibert/__init__.py | bjlee/scibert | 1,143 | 11100537 | import scibert.dataset_readers.classification_dataset_reader
import scibert.models.text_classifier
|
securify/solidity/base/__init__.py | AlexandreH/securify2 | 258 | 11100563 | from securify.grammar import ProductionOps
class AstNodeBase(ProductionOps):
id: int
src: str
@property
def src_range(self):
a, b, _ = map(int, self.src.split(":"))
return a, a + b
@property
def src_line(self):
src_offset = self.src.split(":")[0]
src = self.root().source[:int(src_offset)]
return len([i for i in src if i == "\n"]) + 1
@property
def src_code(self):
a, b = self.src_range
return self.root().source[a:b]
@property
def src_contract(self):
#TODO: Investigate why we can't import at the beginning of file
from securify.solidity.v_0_5_x.solidity_grammar_core import ContractDefinition
if isinstance(self, ContractDefinition):
return self.name
contract = self.find_ancestor_of_type(ContractDefinition)
if contract:
return contract.name
return None
|
libs/configs_old/DOTA/r3det_gwd/cfgs_res101_dota_r3det_gwd_v1.py | Artcs1/RotationDetection | 850 | 11100581 | # -*- coding: utf-8 -*-
from __future__ import division, print_function, absolute_import
import os
import tensorflow as tf
import math
from dataloader.pretrained_weights.pretrain_zoo import PretrainModelZoo
"""
r3det+gwd (only refine stage) + sqrt tau=2 + data aug. + ms + res101 + 3x
FLOPs: 1486599773; Trainable params: 56709560
single scale
This is your result for task 1:
mAP: 0.7507929219725538
ap of each class:
plane:0.8959363254654953,
baseball-diamond:0.8117970905483454,
bridge:0.528941868308621,
ground-track-field:0.7036828276226571,
small-vehicle:0.7773608512825836,
large-vehicle:0.824193538909995,
ship:0.869907508286484,
tennis-court:0.8931429748331345,
basketball-court:0.8306405809724954,
storage-tank:0.8596700800149586,
soccer-ball-field:0.6406646930436465,
roundabout:0.6513733145761638,
harbor:0.6805467355307225,
swimming-pool:0.7095327160387952,
helicopter:0.5845027241542098
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
multi-scale
This is your result for task 1:
mAP: 0.7565987110400665
ap of each class:
plane:0.8964434495830199,
baseball-diamond:0.8170201102441278,
bridge:0.5252222485821921,
ground-track-field:0.729602202372266,
small-vehicle:0.7601882164495246,
large-vehicle:0.8260373681497573,
ship:0.8716819767827122,
tennis-court:0.895671606749032,
basketball-court:0.8124548266228695,
storage-tank:0.8608847379716957,
soccer-ball-field:0.6224300564022891,
roundabout:0.657426649146108,
harbor:0.6805129469115909,
swimming-pool:0.7495597236660946,
helicopter:0.6438445459677189
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_ms
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
multi-scale + flip
This is your result for task 1:
mAP: 0.7579683916708654
ap of each class:
plane:0.8952961695089519,
baseball-diamond:0.8194477842585369,
bridge:0.5243575576743463,
ground-track-field:0.7159062303762178,
small-vehicle:0.7522987121676139,
large-vehicle:0.8282767251249042,
ship:0.8719194994284161,
tennis-court:0.8900495351735876,
basketball-court:0.8399873550181818,
storage-tank:0.8593060497981101,
soccer-ball-field:0.6213106308173056,
roundabout:0.6531238042666215,
harbor:0.7089754248166696,
swimming-pool:0.7442537008416809,
helicopter:0.6450166957918368
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_ms_f
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
multi-scale + mss
This is your result for task 1:
mAP: 0.7622308686293031
ap of each class: plane:0.8956285239247809, baseball-diamond:0.8123129086084642, bridge:0.5338483720916204, ground-track-field:0.7937988239995809, small-vehicle:0.7511751772047529, large-vehicle:0.8213795039925708, ship:0.8685701145257962, tennis-court:0.888685607876141, basketball-court:0.8121412656739693, storage-tank:0.8628395323661605, soccer-ball-field:0.6536075407437665, roundabout:0.650555639430081, harbor:0.728762235286426, swimming-pool:0.7304094256459305, helicopter:0.6297483580695049
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_ms_mss
Username: yangxue
Institute: DetectionTeamUCAS
Emailadress: <EMAIL>
TeamMembers: yangxue, yangjirui
------------------------------------------------------------------------
SWA6 + single scale
This is your result for task 1:
mAP: 0.7536616140168031
ap of each class:
plane:0.8952691912932887,
baseball-diamond:0.820224997940994,
bridge:0.5351902682975013,
ground-track-field:0.6990760862785812,
small-vehicle:0.7768718792058928,
large-vehicle:0.8311637947866269,
ship:0.8707906667992975,
tennis-court:0.9041214885985671,
basketball-court:0.844673715234245,
storage-tank:0.8622850403351549,
soccer-ball-field:0.652075771320803,
roundabout:0.6344222159586387,
harbor:0.6796953794936931,
swimming-pool:0.7077122802895897,
helicopter:0.5913514344191727
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_s_swa6
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
SWA9 + single scale
mAP: 0.7541074969944405
ap of each class:
plane:0.8945929006004023,
baseball-diamond:0.8239698637790639,
bridge:0.5375054158208356,
ground-track-field:0.707263661407391,
small-vehicle:0.7784868305276835,
large-vehicle:0.8313093170826968,
ship:0.8716851894984969,
tennis-court:0.894339902291634,
basketball-court:0.8124139096196356,
storage-tank:0.8621962310027806,
soccer-ball-field:0.6560753654400574,
roundabout:0.6425826383892252,
harbor:0.6781700792445191,
swimming-pool:0.7540293197758513,
helicopter:0.5669918304363327
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_s_swa9
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
SWA9 + multi-scale
This is your result for task 1:
mAP: 0.7611382693726101
ap of each class:
plane:0.8965990887138806,
baseball-diamond:0.8211375961066281,
bridge:0.5274322763152262,
ground-track-field:0.7164191574732031,
small-vehicle:0.7594817184692972,
large-vehicle:0.8309449959450008,
ship:0.8697248627752349,
ennis-court:0.8927766089227556,
basketball-court:0.8504259904102585,
storage-tank:0.8616896266258318,
soccer-ball-field:0.6551601152374349,
roundabout:0.6329228740725862,
harbor:0.7218286216219233,
swimming-pool:0.748803742710907,
helicopter:0.6317267651889841
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_ms_swa9
Username: SJTU-Det
Institute: SJTU
Emailadress: <EMAIL>
TeamMembers: yangxue
SWA9 + multi-scale + mss
This is your result for task 1:
mAP: 0.7667344567887646
ap of each class: plane:0.8932663066411421, baseball-diamond:0.8086480184788661, bridge:0.5328287201353856, ground-track-field:0.782914642745032, small-vehicle:0.7539546562133567, large-vehicle:0.8268751115449491, ship:0.8708668707425938, tennis-court:0.8934725656178293, basketball-court:0.826406161849139, storage-tank:0.8640553822619391, soccer-ball-field:0.6984796440184639, roundabout:0.6471336736334592, harbor:0.7418605732124637, swimming-pool:0.7617818475817874, helicopter:0.5984726771550614
The submitted information is :
Description: RetinaNet_DOTA_R3Det_GWD_3x_20201223_137.7w_ms_swa9_mss
Username: liuqingiqng
Institute: Central South University
Emailadress: <EMAIL>
TeamMembers: liuqingqing
"""
# ------------------------------------------------
VERSION = 'RetinaNet_DOTA_R3Det_GWD_3x_20201223'
NET_NAME = 'resnet101_v1d' # 'MobilenetV2'
# ---------------------------------------- System
ROOT_PATH = os.path.abspath('../../')
print(20*"++--")
print(ROOT_PATH)
GPU_GROUP = "0,1,2"
NUM_GPU = len(GPU_GROUP.strip().split(','))
SHOW_TRAIN_INFO_INTE = 20
SMRY_ITER = 200
SAVE_WEIGHTS_INTE = 27000 * 3
SUMMARY_PATH = os.path.join(ROOT_PATH, 'output/summary')
TEST_SAVE_PATH = os.path.join(ROOT_PATH, 'tools/test_result')
pretrain_zoo = PretrainModelZoo()
PRETRAINED_CKPT = pretrain_zoo.pretrain_weight_path(NET_NAME, ROOT_PATH)
TRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')
EVALUATE_R_DIR = os.path.join(ROOT_PATH, 'output/evaluate_result_pickle/')
# ------------------------------------------ Train and test
RESTORE_FROM_RPN = False
FIXED_BLOCKS = 1 # allow 0~3
FREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone
USE_07_METRIC = True
ADD_BOX_IN_TENSORBOARD = True
MUTILPY_BIAS_GRADIENT = 2.0 # if None, will not multipy
GRADIENT_CLIPPING_BY_NORM = 10.0 # if None, will not clip
CLS_WEIGHT = 1.0
REG_WEIGHT = 2.0
BATCH_SIZE = 1
EPSILON = 1e-5
MOMENTUM = 0.9
LR = 1e-3
DECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20]
MAX_ITERATION = SAVE_WEIGHTS_INTE*20
WARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE)
# -------------------------------------------- Dataset
DATASET_NAME = 'DOTA' # 'pascal', 'coco'
PIXEL_MEAN = [123.68, 116.779, 103.939] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
PIXEL_MEAN_ = [0.485, 0.456, 0.406]
PIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR
IMG_SHORT_SIDE_LEN = [800, 640, 700, 900, 1000, 1100]
IMG_MAX_LENGTH = 1100
CLASS_NUM = 15
IMG_ROTATE = True
RGB2GRAY = True
VERTICAL_FLIP = True
HORIZONTAL_FLIP = True
IMAGE_PYRAMID = True
# --------------------------------------------- Network
SUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None)
SUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0)
PROBABILITY = 0.01
FINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY))
WEIGHT_DECAY = 1e-4
USE_GN = False
NUM_SUBNET_CONV = 4
NUM_REFINE_STAGE = 1
USE_RELU = False
FPN_CHANNEL = 256
FPN_MODE = 'fpn'
# --------------------------------------------- Anchor
LEVEL = ['P3', 'P4', 'P5', 'P6', 'P7']
BASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]
ANCHOR_STRIDE = [8, 16, 32, 64, 128]
ANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)]
ANCHOR_RATIOS = [1, 1 / 2, 2., 1 / 3., 3., 5., 1 / 5.]
ANCHOR_ANGLES = [-90, -75, -60, -45, -30, -15]
ANCHOR_SCALE_FACTORS = None
USE_CENTER_OFFSET = True
METHOD = 'H'
ANGLE_RANGE = 90
# -------------------------------------------- Head
SHARE_NET = True
USE_P5 = True
IOU_POSITIVE_THRESHOLD = 0.5
IOU_NEGATIVE_THRESHOLD = 0.4
REFINE_IOU_POSITIVE_THRESHOLD = [0.6, 0.7]
REFINE_IOU_NEGATIVE_THRESHOLD = [0.5, 0.6]
NMS = True
NMS_IOU_THRESHOLD = 0.1
MAXIMUM_DETECTIONS = 100
FILTERED_SCORE = 0.05
VIS_SCORE = 0.4
# -------------------------------------------- GWD
GWD_TAU = 2.0
GWD_FUNC = tf.sqrt
|
examples/02.random_scene.py | blaine141/NVISII | 149 | 11100594 | <reponame>blaine141/NVISII
# 02.random_scene.py
#
# This shows how to generate a randomized scene using a couple built-in mesh
# types and some randomized materials.
import nvisii
from random import *
import colorsys
opt = lambda: None
opt.nb_objs = 10000
opt.spp = 16
opt.width = 1920
opt.height = 1080
opt.out = '02_random_scene.png'
# nvisii uses sets of components to represent a scene.
# We can increase the max component limit here if necessary.
# In this case, we'll need 16 meshes, a material for each object,
# and finally a transform for each object as well as one more for the camera.
nvisii.initialize(
headless = True,
verbose = True,
lazy_updates = True,
max_entities = opt.nb_objs + 1,
max_transforms = opt.nb_objs + 1,
max_materials = opt.nb_objs,
max_meshes = 16
# these are also available
# max_lights, max_textures, & max_cameras
)
# Turn on the denoiser
nvisii.enable_denoiser()
# Create a camera
camera = nvisii.entity.create(
name = "camera",
transform = nvisii.transform.create("camera"),
camera = nvisii.camera.create(
name = "camera",
aspect = float(opt.width)/float(opt.height)
)
)
camera.get_transform().look_at(at = (0,0,0), up = (1,0,0), eye = (0,0,5))
nvisii.set_camera_entity(camera)
# Lets create a random scene.
# First lets pre-load some mesh components.
nvisii.mesh.create_sphere('m_0')
nvisii.mesh.create_torus_knot('m_1')
nvisii.mesh.create_teapotahedron('m_2')
nvisii.mesh.create_box('m_3')
nvisii.mesh.create_capped_cone('m_4')
nvisii.mesh.create_capped_cylinder('m_5')
nvisii.mesh.create_capsule('m_6')
nvisii.mesh.create_cylinder('m_7')
nvisii.mesh.create_disk('m_8')
nvisii.mesh.create_dodecahedron('m_9')
nvisii.mesh.create_icosahedron('m_10')
nvisii.mesh.create_icosphere('m_11')
nvisii.mesh.create_rounded_box('m_12')
nvisii.mesh.create_spring('m_13')
nvisii.mesh.create_torus('m_14')
nvisii.mesh.create_tube('m_15')
def add_random_obj(name = "name"):
# this function adds a random object that uses one of the pre-loaded mesh
# components, assigning a random pose and random material to that object.
obj = nvisii.entity.create(
name = name,
transform = nvisii.transform.create(name),
material = nvisii.material.create(name)
)
mesh_id = randint(0,15)
# set the mesh. (Note that meshes can be shared, saving memory)
mesh = nvisii.mesh.get(f'm_{mesh_id}')
obj.set_mesh(mesh)
obj.get_transform().set_position((
uniform(-5,5),
uniform(-5,5),
uniform(-1,3)
))
obj.get_transform().set_rotation((
uniform(0,1), # X
uniform(0,1), # Y
uniform(0,1), # Z
uniform(0,1) # W
))
s = uniform(0.05,0.15)
obj.get_transform().set_scale((
s,s,s
))
rgb = colorsys.hsv_to_rgb(
uniform(0,1),
uniform(0.7,1),
uniform(0.7,1)
)
obj.get_material().set_base_color(rgb)
mat = obj.get_material()
# Some logic to generate "natural" random materials
material_type = randint(0,2)
# Glossy / Matte Plastic
if material_type == 0:
if randint(0,2): mat.set_roughness(uniform(.9, 1))
else : mat.set_roughness(uniform(.0,.1))
# Metallic
if material_type == 1:
mat.set_metallic(uniform(0.9,1))
if randint(0,2): mat.set_roughness(uniform(.9, 1))
else : mat.set_roughness(uniform(.0,.1))
# Glass
if material_type == 2:
mat.set_transmission(uniform(0.9,1))
# controls outside roughness
if randint(0,2): mat.set_roughness(uniform(.9, 1))
else : mat.set_roughness(uniform(.0,.1))
# controls inside roughness
if randint(0,2): mat.set_transmission_roughness(uniform(.9, 1))
else : mat.set_transmission_roughness(uniform(.0,.1))
mat.set_sheen(uniform(0,1)) # <- soft velvet like reflection near edges
mat.set_clearcoat(uniform(0,1)) # <- Extra, white, shiny layer. Good for car paint.
if randint(0,1): mat.set_anisotropic(uniform(0.9,1)) # elongates highlights
# (lots of other material parameters are listed in the docs)
# Now, use the above function to make a bunch of random objects
for i in range(opt.nb_objs):
add_random_obj(str(i))
print("\rcreating random object", i, end="")
print(" - done!")
nvisii.render_to_file(
width = opt.width,
height = opt.height,
samples_per_pixel = opt.spp,
file_path = opt.out
)
nvisii.deinitialize() |
pyGeno/tools/SingletonManager.py | ealong/pyGeno | 309 | 11100601 | #This thing is wonderful
objects = {}
def add(obj, objName='') :
if objName == '' :
key = obj.name
else :
key = objName
if key not in objects :
objects[key] = obj
return obj
def contains(k) :
return k in objects
def get(objName) :
try :
return objects[objName]
except :
return None
|
lenstronomy/LensModel/Profiles/epl_numba.py | smericks/lenstronomy | 107 | 11100602 | <gh_stars>100-1000
__author__ = 'ewoudwempe'
import numpy as np
import lenstronomy.Util.param_util as param_util
from lenstronomy.LensModel.Profiles.base_profile import LensProfileBase
from lenstronomy.Util.numba_util import jit, nan_to_num
__all__ = ['EPL_numba']
class EPL_numba(LensProfileBase):
""""
Elliptical Power Law mass profile - computation accelerated with numba
.. math::
\\kappa(x, y) = \\frac{3-\\gamma}{2} \\left(\\frac{\\theta_{E}}{\\sqrt{q x^2 + y^2/q}} \\right)^{\\gamma-1}
with :math:`\\theta_{E}` is the (circularized) Einstein radius,
:math:`\\gamma` is the negative power-law slope of the 3D mass distributions,
:math:`q` is the minor/major axis ratio,
and :math:`x` and :math:`y` are defined in a coordinate system aligned with the major and minor axis of the lens.
In terms of eccentricities, this profile is defined as
.. math::
\\kappa(r) = \\frac{3-\\gamma}{2} \\left(\\frac{\\theta'_{E}}{r \\sqrt{1 − e*\\cos(2*\\phi)}} \\right)^{\\gamma-1}
with :math:`\\epsilon` is the ellipticity defined as
.. math::
\\epsilon = \\frac{1-q^2}{1+q^2}
And an Einstein radius :math:`\\theta'_{\\rm E}` related to the definition used is
.. math::
\\left(\\frac{\\theta'_{\\rm E}}{\\theta_{\\rm E}}\\right)^{2} = \\frac{2q}{1+q^2}.
The mathematical form of the calculation is presented by <NAME> (2015), https://arxiv.org/abs/1507.01819.
The current implementation is using hyperbolic functions. The paper presents an iterative calculation scheme,
converging in few iterations to high precision and accuracy.
A (slower) implementation of the same model using hyperbolic functions without the iterative calculation
is accessible as 'EPL' not requiring numba.
"""
param_names = ['theta_E', 'gamma', 'e1', 'e2', 'center_x', 'center_y']
lower_limit_default = {'theta_E': 0, 'gamma': 1.5, 'e1': -0.5, 'e2': -0.5, 'center_x': -100, 'center_y': -100}
upper_limit_default = {'theta_E': 100, 'gamma': 2.5, 'e1': 0.5, 'e2': 0.5, 'center_x': 100, 'center_y': 100}
def __init__(self):
super(EPL_numba).__init__()
@staticmethod
@jit()
def function(x, y, theta_E, gamma, e1, e2, center_x=0., center_y=0.):
"""
:param x: x-coordinate (angle)
:param y: y-coordinate (angle)
:param theta_E: Einstein radius (angle), pay attention to specific definition!
:param gamma: logarithmic slope of the power-law profile. gamma=2 corresponds to isothermal
:param e1: eccentricity component
:param e2: eccentricity component
:param center_x: x-position of lens center
:param center_y: y-position of lens center
:return: lensing potential
"""
z, b, t, q, ang = param_transform(x, y, theta_E, gamma, e1, e2, center_x, center_y)
alph = alpha(z.real, z.imag, b, q, t)
return 1/(2-t)*(z.real*alph.real+z.imag*alph.imag)
@staticmethod
@jit()
def derivatives(x, y, theta_E, gamma, e1, e2, center_x=0., center_y=0.):
"""
:param x: x-coordinate (angle)
:param y: y-coordinate (angle)
:param theta_E: Einstein radius (angle), pay attention to specific definition!
:param gamma: logarithmic slope of the power-law profile. gamma=2 corresponds to isothermal
:param e1: eccentricity component
:param e2: eccentricity component
:param center_x: x-position of lens center
:param center_y: y-position of lens center
:return: deflection angles alpha_x, alpha_y
"""
z, b, t, q, ang = param_transform(x, y, theta_E, gamma, e1, e2, center_x, center_y)
alph = alpha(z.real, z.imag, b, q, t) * np.exp(1j*ang)
return alph.real, alph.imag
@staticmethod
@jit()
def hessian(x, y, theta_E, gamma, e1, e2, center_x=0., center_y=0.):
"""
:param x: x-coordinate (angle)
:param y: y-coordinate (angle)
:param theta_E: Einstein radius (angle), pay attention to specific definition!
:param gamma: logarithmic slope of the power-law profile. gamma=2 corresponds to isothermal
:param e1: eccentricity component
:param e2: eccentricity component
:param center_x: x-position of lens center
:param center_y: y-position of lens center
:return: Hessian components f_xx, f_yy, f_xy
"""
z, b, t, q, ang_ell = param_transform(x, y, theta_E, gamma, e1, e2, center_x, center_y)
ang = np.angle(z)
#r = np.abs(z)
zz_ell = z.real*q+1j*z.imag
R = np.abs(zz_ell)
phi = np.angle(zz_ell)
#u = np.minimum(nan_to_num((b/R)**t),1e100)
u = np.fmin((b/R)**t, 1e10) # I remove all factors of (b/R)**t to only have to remove nans once.
# The np.fmin is a regularisation near R=0, to avoid overflows
# in the magnification calculations
kappa = (2-t)/2
Roverr = np.sqrt(np.cos(ang)**2*q**2+np.sin(ang)**2)
Omega = omega(phi, t, q)
alph = (2*b)/(1+q)/b*Omega
gamma_shear = -np.exp(2j*(ang+ang_ell))*kappa + (1-t)*np.exp(1j*(ang+2*ang_ell)) * alph*Roverr
f_xx = (kappa + gamma_shear.real)*u
f_yy = (kappa - gamma_shear.real)*u
f_xy = gamma_shear.imag*u
# Fix the nans if x=y=0 is filled in
return f_xx, f_xy, f_xy, f_yy
@jit()
def param_transform(x, y, theta_E, gamma, e1, e2, center_x=0., center_y=0.):
"""Converts the parameters from lenstronomy definitions (as defined in PEMD) to the definitions of Tessore+ (2015)"""
t = gamma-1
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
x_shift = x - center_x
y_shift = y - center_y
ang = phi_G
z = np.exp(-1j*phi_G) * (x_shift + y_shift*1j)
return z, theta_E*np.sqrt(q), t, q, ang
@jit()
def alpha(x, y, b, q, t, Omega=None):
"""
Calculates the complex deflection
:param x: x-coordinate (angle)
:param y: y-coordinate (angle)
:param b: Einstein radius (angle), pay attention to specific definition!
:param q: axis ratio
:param t: logarithmic power-law slope. Is t=gamma-1
:param Omega: If given, use this Omega (to avoid recalculations)
:return: complex deflection angle
"""
zz = x*q + 1j*y
R = np.abs(zz)
phi = np.angle(zz)
if Omega is None:
Omega = omega(phi, t, q)
# Omega = omega(phi, t, q)
alph = (2*b)/(1+q)*nan_to_num((b/R)**t*R/b)*Omega
return alph
@jit(fastmath=True) # Because of the reduction nature of this, relaxing commutativity actually matters a lot (4x speedup).
def omega(phi, t, q, niter_max=200, tol=1e-16):
f = (1-q)/(1+q)
omegas = np.zeros_like(phi, dtype=np.complex128)
niter = min(niter_max, int(np.log(tol)/np.log(f))+2) # The absolute value of each summand is always less than f, hence this limit for the number of iterations.
Omega = 1*np.exp(1j*phi)
fact = -f*np.exp(2j*phi)
for n in range(1, niter):
omegas += Omega
Omega *= (2*n-(2-t))/(2*n+(2-t)) * fact
omegas += Omega
return omegas
|
test/core/tests/lineage.py | oliverholworthy/metaflow | 5,821 | 11100632 | from metaflow_test import MetaflowTest, ExpectationFailed, steps
class LineageTest(MetaflowTest):
PRIORITY = 1
@steps(0, ['start'])
def step_start(self):
self.lineage = (self._current_step,)
@steps(1, ['join'])
def step_join(self):
# we can't easily account for the number of foreach splits,
# so we only care about unique lineages (hence set())
self.lineage = (tuple(sorted({x.lineage for x in inputs})),
self._current_step)
@steps(2, ['all'])
def step_all(self):
self.lineage += (self._current_step,)
def check_results(self, flow, checker):
from collections import defaultdict
join_sets = defaultdict(set)
lineages = {}
graph = flow._graph
# traverse all paths from the start step to the end,
# collect lineages on the way and finally compare them
# to the lineages produced by the actual run
def traverse(step, lineage):
if graph[step].type == 'join':
join_sets[step].add(tuple(lineage))
if len(join_sets[step]) < len(graph[step].in_funcs):
return
else:
lineage = (tuple(sorted(join_sets[step])),)
lineages[step] = lineage + (step,)
for n in graph[step].out_funcs:
traverse(n, lineage + (step,))
traverse('start', ())
for step in flow:
checker.assert_artifact(step.name, 'lineage', lineages[step.name])
|
12-productionize-deploy-flask/deploy-models/review_classifier.py | jugalh/data-x-plaksha | 117 | 11100655 | <filename>12-productionize-deploy-flask/deploy-models/review_classifier.py<gh_stars>100-1000
import cloudpickle as pickle
def classifier(test_data):
"""
:param test_data: data that needs prediction list or single parameter
:return: predicted class rotten or fresh
"""
# Load the pickle data
model = pickle.load(open('movie_model.pkl','rb'))
vectorizer = pickle.load(open('vectorizer.pkl','rb'))
# Check for the type
if type(test_data) != list:
test_data = list(test_data)
# Transform the test data
transformed = vectorizer.transform(test_data).toarray()
# Predict the class
predicted = model.predict(transformed).tolist()
return predicted
|
exercises/fr/test_03_15.py | Jette16/spacy-course | 2,085 | 11100671 | def test():
assert Doc.has_extension(
"author"
), "As-tu défini l'extension author du Doc ?"
ext = Doc.get_extension("author")
assert all(
v is None for v in ext
), "As-tu affecté la valeur par défaut à l'extension author ?"
assert Doc.has_extension("book"), "As-tu défini l'extension book du Doc ?"
ext = Doc.get_extension("book")
assert all(
v is None for v in ext
), "As-tu affecté la valeur par défaut à l'extension book ?"
assert (
"nlp.pipe(DATA, as_tuples=True)" in __solution__
), "As-tu utilisé nlp.pipe avec as_tuples=True?"
assert (
'doc._.book = context["book"]' in __solution__
), "As-tu actualisé l'extension doc._.book avec la valeur de contexte de 'book' ?"
assert (
'doc._.author = context["author"]' in __solution__
), "As-tu actualisé l'extension doc._.author avec la valeur de contexte de 'author' ?"
__msg__.good(
"Bien joué ! Cette même technique est utile pour de nombreuses taches. "
"Par exemple, tu pourrais passer des numéros de page ou de paragraphe "
"pour lier le Doc traité à sa position dans un plus grand document. Ou "
"tu pourrais passer d'autres données structurées comme des ID faisant "
"référence à une base de connaissances."
)
|
example_image_resize.py | viddik13/katna | 125 | 11100692 | <gh_stars>100-1000
import os.path
import cv2
from Katna.image import Image
def main():
# Extract specific number of key frames from video
img_module = Image()
# folder to save extracted images
output_folder_cropped_image = "resizedimages"
if not os.path.isdir(os.path.join(".", output_folder_cropped_image)):
os.mkdir(os.path.join(".", output_folder_cropped_image))
# crop dimentions
resize_width = 500
resize_height = 600
# Image file path
image_file_path = os.path.join(".", "tests", "data", "bird_img_for_crop.jpg")
print(f"image_file_path = {image_file_path}")
resized_image = img_module.resize_image(
file_path=image_file_path,
target_width=resize_width,
target_height=resize_height,
down_sample_factor=8,
)
# cv2.imshow("resizedImage", resized_image)
# cv2.waitKey(0)
img_module.save_image_to_disk(
resized_image,
file_path=output_folder_cropped_image,
file_name="resized_image",
file_ext=".jpeg",
)
main()
|
cactus/utils/ipc.py | danielchasehooper/Cactus | 1,048 | 11100718 | <gh_stars>1000+
import os
import logging
def signal(signal, data=None):
if data is None:
data = {}
if not os.environ.get('DESKTOPAPP'):
return
data["signal"] = signal
logging.warning("", data)
|
neural_sp/trainers/optimizer.py | ishine/neural_sp | 577 | 11100731 | <gh_stars>100-1000
# Copyright 2019 Kyoto University (<NAME>)
# Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
"""Select optimizer."""
import logging
import torch
logger = logging.getLogger(__name__)
def set_optimizer(model, optimizer, lr, weight_decay=0.):
"""Set optimizer.
Args:
model (): model class
optimizer (str): name of optimizer
lr (float): learning rate
weight_decay (float): L2 penalty for weight decay
Returns:
opt (torch.optim): optimizer
"""
parameters = [p for p in model.parameters() if p.requires_grad]
logger.info("===== Freezed parameters =====")
for n in [n for n, p in model.named_parameters() if not p.requires_grad]:
logger.info("%s" % n)
if optimizer == 'sgd':
opt = torch.optim.SGD(parameters,
lr=lr,
weight_decay=weight_decay,
nesterov=False)
elif optimizer == 'momentum':
opt = torch.optim.SGD(parameters,
lr=lr,
momentum=0.9,
weight_decay=weight_decay,
nesterov=False)
elif optimizer == 'nesterov':
opt = torch.optim.SGD(parameters,
lr=lr,
# momentum=0.9,
momentum=0.99,
weight_decay=weight_decay,
nesterov=True)
elif optimizer == 'adadelta':
opt = torch.optim.Adadelta(parameters,
rho=0.9, # pytorch default
# rho=0.95, # chainer default
# eps=1e-8, # pytorch default
# eps=1e-6, # chainer default
eps=lr,
weight_decay=weight_decay)
elif optimizer == 'adam':
opt = torch.optim.Adam(parameters,
lr=lr,
weight_decay=weight_decay)
elif optimizer == 'noam':
opt = torch.optim.Adam(parameters,
lr=0,
betas=(0.9, 0.98),
eps=1e-09,
weight_decay=weight_decay)
elif optimizer == 'adagrad':
opt = torch.optim.Adagrad(parameters,
lr=lr,
weight_decay=weight_decay)
elif optimizer == 'rmsprop':
opt = torch.optim.RMSprop(parameters,
lr=lr,
weight_decay=weight_decay)
else:
raise NotImplementedError(optimizer)
return opt
|
datasets/igbo_english_machine_translation/igbo_english_machine_translation.py | dkajtoch/datasets | 10,608 | 11100737 | <reponame>dkajtoch/datasets<filename>datasets/igbo_english_machine_translation/igbo_english_machine_translation.py
# coding=utf-8
# Copyright 2020 HuggingFace Datasets 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.
# Lint as: python3
import datasets
_DESCRIPTION = """\
Parallel Igbo-English Dataset
"""
_HOMEPAGE_URL = "https://github.com/IgnatiusEzeani/IGBONLP/tree/master/ig_en_mt"
_CITATION = """\
@misc{ezeani2020igboenglish,
title={Igbo-English Machine Translation: An Evaluation Benchmark},
author={<NAME> and <NAME> and <NAME> and <NAME> and <NAME>},
year={2020},
eprint={2004.00648},
archivePrefix={arXiv},
primaryClass={cs.CL},
url={https://arxiv.org/abs/2004.00648}
}
"""
_VERSION = "1.0.0"
_TRAIN_EN = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/train.en"
_VALID_EN = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/val.en"
_TEST_EN = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/test.en"
_TRAIN_IG = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/train.ig"
_VALID_IG = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/val.ig"
_TEST_IG = "https://raw.githubusercontent.com/IgnatiusEzeani/IGBONLP/master/ig_en_mt/benchmark_dataset/test.ig"
_LANGUAGE_PAIRS = [
("ig", "en"),
]
class IgboEnglishMachineTranslationConfig(datasets.BuilderConfig):
def __init__(self, *args, lang1=None, lang2=None, **kwargs):
super().__init__(
*args,
name=f"{lang1}-{lang2}",
**kwargs,
)
self.lang1 = lang1
self.lang2 = lang2
class IgboEnglishMachineTranslation(datasets.GeneratorBasedBuilder):
BUILDER_CONFIGS = [
IgboEnglishMachineTranslationConfig(
lang1=lang1,
lang2=lang2,
description=f"Translating {lang1} to {lang2} or vice versa",
version=datasets.Version(_VERSION),
)
for lang1, lang2 in _LANGUAGE_PAIRS
]
BUILDER_CONFIG_CLASS = IgboEnglishMachineTranslationConfig
def _info(self):
return datasets.DatasetInfo(
description=_DESCRIPTION,
features=datasets.Features(
{
"id": datasets.Value("string"),
"translation": datasets.Translation(languages=(self.config.lang1, self.config.lang2)),
},
),
supervised_keys=None,
homepage=_HOMEPAGE_URL,
citation=_CITATION,
)
def _split_generators(self, dl_manager):
train_en = dl_manager.download_and_extract(_TRAIN_EN)
train_ig = dl_manager.download_and_extract(_TRAIN_IG)
valid_en = dl_manager.download_and_extract(_VALID_EN)
valid_ig = dl_manager.download_and_extract(_VALID_IG)
test_en = dl_manager.download_and_extract(_TEST_EN)
test_ig = dl_manager.download_and_extract(_TEST_IG)
return [
datasets.SplitGenerator(
name=datasets.Split.TRAIN,
gen_kwargs={"ig_datapath": train_ig, "en_datapath": train_en},
),
datasets.SplitGenerator(
name=datasets.Split.VALIDATION,
gen_kwargs={"ig_datapath": valid_ig, "en_datapath": valid_en},
),
datasets.SplitGenerator(
name=datasets.Split.TEST,
gen_kwargs={"ig_datapath": test_ig, "en_datapath": test_en},
),
]
def _generate_examples(self, ig_datapath, en_datapath):
with open(ig_datapath, encoding="utf-8") as f1, open(en_datapath, encoding="utf-8") as f2:
for sentence_counter, (x, y) in enumerate(zip(f1, f2)):
x = x.strip()
y = y.strip()
result = (
sentence_counter,
{
"id": str(sentence_counter),
"translation": {"ig": x, "en": y},
},
)
yield result
|
tests/links_tests/scaler_tests/test_standard_scaler.py | pfnet/chainerchem | 184 | 11100744 | <reponame>pfnet/chainerchem<gh_stars>100-1000
import os
import chainer
import numpy
import pytest
from chainer import serializers, Variable, cuda # NOQA
from chainer_chemistry.links.scaler.standard_scaler import StandardScaler
@pytest.fixture
def data():
x = numpy.array(
[[0.1, 10., 0.3],
[0.2, 20., 0.1],
[0.3, 30., 0.],
[0.4, 40., 0.]],
dtype=numpy.float32)
expect_x_scaled = numpy.array(
[[-1.3416407, -1.3416408, 1.6329931],
[-0.44721353, -0.4472136, 0.],
[0.44721368, 0.4472136, -0.8164965],
[1.3416407, 1.3416408, -0.8164965]],
dtype=numpy.float32)
return x, expect_x_scaled
@pytest.mark.parametrize('indices', [None, [0], [1, 2]])
def test_standard_scaler_transform(data, indices):
x, expect_x_scaled = data
scaler = StandardScaler()
scaler.fit(x, indices=indices)
x_scaled = scaler.transform(x)
if indices is None:
indices = numpy.arange(x.shape[1])
for index in range(x.shape[1]):
if index in indices:
assert numpy.allclose(x_scaled[:, index],
expect_x_scaled[:, index])
else:
assert numpy.allclose(x_scaled[:, index], x[:, index])
def test_standard_scaler_transform_variable(data):
x, expect_x_scaled = data
xvar = Variable(x)
scaler = StandardScaler()
scaler.fit(xvar)
x_scaled = scaler.transform(xvar)
assert isinstance(x_scaled, Variable)
assert numpy.allclose(x_scaled.array, expect_x_scaled)
@pytest.mark.gpu
def test_standard_scaler_transform_gpu(data):
x, expect_x_scaled = data
scaler = StandardScaler()
scaler.to_gpu()
x = cuda.to_gpu(x)
scaler.fit(x)
x_scaled = scaler.transform(x)
assert isinstance(x_scaled, cuda.cupy.ndarray)
assert numpy.allclose(cuda.to_cpu(x_scaled), expect_x_scaled)
@pytest.mark.parametrize('indices', [None, [0], [1, 2]])
def test_standard_scaler_inverse_transform(data, indices):
x, expect_x_scaled = data
scaler = StandardScaler()
scaler.fit(x, indices=indices)
x_inverse = scaler.inverse_transform(expect_x_scaled)
if indices is None:
indices = numpy.arange(x.shape[1])
for index in range(x.shape[1]):
if index in indices:
assert numpy.allclose(x_inverse[:, index], x[:, index])
else:
assert numpy.allclose(x_inverse[:, index],
expect_x_scaled[:, index])
@pytest.mark.parametrize('axis', [1, 2])
def test_standard_scaler_3darray(data, axis):
x, expect_x_scaled = data
s0, s1 = x.shape
if axis == 1:
# feature axis is 1, insert other axis to 2nd axis
x = numpy.broadcast_to(x[:, :, None], (s0, s1, 2))
expect_x_scaled = numpy.broadcast_to(
expect_x_scaled[:, :, None], (s0, s1, 2))
elif axis == 2:
# feature axis is 2, insert other axis to 1st axis
x = numpy.broadcast_to(x[:, None, :], (s0, 3, s1))
expect_x_scaled = numpy.broadcast_to(
expect_x_scaled[:, None, :], (s0, 3, s1))
assert x.ndim == 3
indices = None
scaler = StandardScaler()
scaler.fit(x, indices=indices, axis=axis)
x_scaled = scaler.transform(x, axis=axis)
assert x_scaled.shape == expect_x_scaled.shape
assert numpy.allclose(x_scaled, expect_x_scaled, atol=1e-7)
x_inverse = scaler.inverse_transform(expect_x_scaled, axis=axis)
for index in numpy.arange(x.shape[1]):
assert numpy.allclose(x_inverse[:, index], x[:, index], atol=1e-7)
def test_standard_scaler_fit_transform(data):
x, expect_x_scaled = data
scaler = StandardScaler()
x_scaled = scaler.fit_transform(x)
assert numpy.allclose(x_scaled, expect_x_scaled)
# TODO(nakago): fix Chainer serializer.
# Behavior changed from numpy versioin 1.16.3.
# allow_pickle=True must be passed to numpy.load function,
# in order to load `None`.
# For now, skip test for serialize `None`.
# @pytest.mark.parametrize('indices', [None, [0]])
@pytest.mark.parametrize('indices', [[0]])
def test_standard_scaler_serialize(tmpdir, data, indices):
x, expect_x_scaled = data
scaler = StandardScaler()
scaler.fit(x, indices=indices)
scaler_filepath = os.path.join(str(tmpdir), 'scaler.npz')
serializers.save_npz(scaler_filepath, scaler)
scaler2 = StandardScaler()
serializers.load_npz(scaler_filepath, scaler2)
# print('scaler2 attribs:', scaler2.mean, scaler2.std, scaler2.indices)
assert numpy.allclose(scaler.mean, scaler2.mean)
assert numpy.allclose(scaler.std, scaler2.std)
assert scaler.indices == scaler2.indices
def test_standard_scaler_assert_raises():
x = numpy.array([[0.1, 0.2, 0.3], [0.5, 0.3, 0.1]],
dtype=numpy.float32)
scaler = StandardScaler()
# call transform before fit raises error
with pytest.raises(AttributeError):
scaler.transform(x)
with pytest.raises(AttributeError):
scaler.inverse_transform(x)
def test_standard_scaler_transform_zero_std():
x = numpy.array([[1, 2], [1, 2], [1, 2]], dtype=numpy.float32)
expect_x_scaled = numpy.array([[0, 0], [0, 0], [0, 0]],
dtype=numpy.float32)
scaler = StandardScaler()
scaler.fit(x)
x_scaled = scaler.transform(x)
assert numpy.allclose(x_scaled, expect_x_scaled)
def test_standard_scaler_forward(data):
# test `forward` and `__call__` method.
indices = [0]
x, expect_x_scaled = data
scaler = StandardScaler()
scaler.fit(x, indices=indices)
x_scaled_transform = scaler.transform(x)
x_scaled_forward = scaler.forward(x)
assert numpy.allclose(x_scaled_transform, x_scaled_forward)
if int(chainer.__version__.split('.')[0]) >= 5:
# `__call__` invokes `forward` method from version 5.
# Skip test for chainer v4.
x_scaled_call = scaler(x)
assert numpy.allclose(x_scaled_transform, x_scaled_call)
if __name__ == '__main__':
pytest.main([__file__, '-v', '-s'])
|
web/cook_resp.py | wnbh/iCopy | 232 | 11100786 | from utils import load
import pymongo
cfg = load.cfg
# ### Mongodb
myclient = pymongo.MongoClient(
f"{cfg['database']['db_connect_method']}://{load.user}:{load.passwd}@{cfg['database']['db_addr']}",
port=cfg["database"]["db_port"],
connect=False,
)
mydb = myclient[cfg["database"]["db_name"]]
fav_col = mydb["fav_col"]
task_list = mydb["task_list"]
db_counters = mydb["counters"]
def get_drive_list():
drivelist = {}
all_drive = load.all_drive
drivelist['data'] = all_drive
drivelist['code'] = 20000
drivelist['message'] = ""
return drivelist
def cook_fav_info():
favlist = {}
fav_info_array = []
fav_info = fav_col.find({"fav_type":"fav"},{"_id": 0})
for each in fav_info:
if 'fav_size' and 'fav_object' in each:
each['show_size'] = str(each['fav_size']) + " " +each['fav_size_tail']
each['percent'] = float(each['fav_object'] / 4000 )
each['show_percent'] = str(each['percent']) + "%"
else:
each['fav_size'] = "UNKNOW"
each['fav_object'] = "UNKNOW"
each['show_size'] = "UNKNOW"
each['show_percent'] = "UNKNOW"
fav_info_array.append(each)
favlist['data'] = fav_info_array
favlist['code'] = 20000
favlist['message'] = ""
return favlist
def cook_task_info():
tasklist = {}
task_info_array = []
task_info = task_list.find({"status":1,"error":0})
for each in task_info:
each['show_status'] = "Completed"
if "task_total_prog_size_tail" in each:
each['show_size'] = str(each['task_total_prog_size']) + " " + each['task_total_prog_size_tail']
else:
each['show_size'] = "UNKNOW"
task_info_array.append(each)
tasklist['code'] = 20000
tasklist['data'] = task_info_array
tasklist['message'] = ""
return tasklist
|
cronyo/deploy.py | 0xflotus/cronyo | 335 | 11100796 | <filename>cronyo/deploy.py
from botocore.client import ClientError
import os
from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
try:
from cronyo import logger
from cronyo.config import config
from cronyo.aws_api import iam, aws_lambda, events, region, check_aws_credentials
except ImportError:
import logger
from config import config
from aws_api import iam, aws_lambda, events, region, check_aws_credentials
logger = logger.setup()
LIVE = 'live'
REVISIONS = 5
POLICY = """{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}"""
ASSUMED_ROLE_POLICY = """{
"Version": "2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
}
}
]
}"""
WIRING = [
{
"lambda": {
"FunctionName": "cronyo-http_post",
"Handler": "cronyo.http_post",
"MemorySize": 128,
"Timeout": 30
}
},
{
"lambda": {
"FunctionName": "cronyo-http_get",
"Handler": "cronyo.http_get",
"MemorySize": 128,
"Timeout": 30
}
}
]
def prepare_zip():
from pkg_resources import resource_filename as resource
from yaml import dump
logger.info('creating/updating cronyo.zip')
with ZipFile('cronyo.zip', 'w', ZIP_DEFLATED) as zipf:
info = ZipInfo('config.yml')
info.external_attr = 0o664 << 16
zipf.writestr(info, dump(config))
zipf.write(resource('cronyo', 'config.py'), 'config.py')
zipf.write(resource('cronyo', 'cronyo.py'), 'cronyo.py')
zipf.write(resource('cronyo', 'logger.py'), 'logger.py')
for root, dirs, files in os.walk(resource('cronyo', 'vendor')):
for file in files:
real_file = os.path.join(root, file)
relative_file = os.path.relpath(real_file,
resource('cronyo', ''))
zipf.write(real_file, relative_file)
def role():
new_role = False
try:
logger.info('finding role')
iam('get_role', RoleName='cronyo')
except ClientError:
logger.info('role not found. creating')
iam('create_role', RoleName='cronyo',
AssumeRolePolicyDocument=ASSUMED_ROLE_POLICY)
new_role = True
role_arn = iam('get_role', RoleName='cronyo', query='Role.Arn')
logger.debug('role_arn={}'.format(role_arn))
logger.info('updating role policy')
iam('put_role_policy', RoleName='cronyo', PolicyName='cronyo',
PolicyDocument=POLICY)
if new_role:
from time import sleep
logger.info('waiting for role policy propagation')
sleep(5)
return role_arn
def _cleanup_old_versions(name):
logger.info('cleaning up old versions of {0}. Keeping {1}'.format(
name, REVISIONS))
versions = _versions(name)
for version in versions[0:(len(versions) - REVISIONS)]:
logger.debug('deleting {} version {}'.format(name, version))
aws_lambda('delete_function',
FunctionName=name,
Qualifier=version)
def _function_alias(name, version, alias=LIVE):
try:
logger.info('creating function alias {0} for {1}:{2}'.format(
alias, name, version))
arn = aws_lambda('create_alias',
FunctionName=name,
FunctionVersion=version,
Name=alias,
query='AliasArn')
except ClientError:
logger.info('alias {0} exists. updating {0} -> {1}:{2}'.format(
alias, name, version))
arn = aws_lambda('update_alias',
FunctionName=name,
FunctionVersion=version,
Name=alias,
query='AliasArn')
return arn
def _versions(name):
versions = aws_lambda('list_versions_by_function',
FunctionName=name,
query='Versions[].Version')
return versions[1:]
def _get_version(name, alias=LIVE):
return aws_lambda('get_alias',
FunctionName=name,
Name=alias,
query='FunctionVersion')
def rollback_lambda(name, alias=LIVE):
all_versions = _versions(name)
live_version = _get_version(name, alias)
try:
live_index = all_versions.index(live_version)
if live_index < 1:
raise RuntimeError('Cannot find previous version')
prev_version = all_versions[live_index - 1]
logger.info('rolling back to version {}'.format(prev_version))
_function_alias(name, prev_version)
except RuntimeError as error:
logger.error('Unable to rollback. {}'.format(repr(error)))
def rollback(alias=LIVE):
for lambda_function in ('cronyo-track'):
rollback_lambda(lambda_function, alias)
def create_update_lambda(role_arn, wiring):
name, handler, memory, timeout = (wiring[k] for k in ('FunctionName',
'Handler',
'MemorySize',
'Timeout'))
try:
logger.info('finding lambda function')
function_arn = aws_lambda('get_function',
FunctionName=name,
query='Configuration.FunctionArn')
except ClientError:
function_arn = None
if not function_arn:
logger.info('creating new lambda function {}'.format(name))
with open('cronyo.zip', 'rb') as zf:
function_arn, version = aws_lambda('create_function',
FunctionName=name,
Runtime='python3.8',
Role=role_arn,
Handler=handler,
MemorySize=memory,
Timeout=timeout,
Publish=True,
Code={'ZipFile': zf.read()},
query='[FunctionArn, Version]')
else:
logger.info('updating lambda function {}'.format(name))
aws_lambda('update_function_configuration',
FunctionName=name,
Runtime='python3.8',
Role=role_arn,
Handler=handler,
MemorySize=memory,
Timeout=timeout)
with open('cronyo.zip', 'rb') as zf:
function_arn, version = aws_lambda('update_function_code',
FunctionName=name,
Publish=True,
ZipFile=zf.read(),
query='[FunctionArn, Version]')
function_arn = _function_alias(name, version)
_cleanup_old_versions(name)
logger.debug('function_arn={} ; version={}'.format(function_arn, version))
return function_arn
def preflight_checks():
logger.info('checking aws credentials and region')
if region() is None:
logger.error('Region is not set up. please run aws configure')
return False
try:
check_aws_credentials()
except AttributeError:
logger.error('AWS credentials not found. please run aws configure')
return False
return True
def run():
prepare_zip()
role_arn = role()
for component in WIRING + config.get("extra_wiring", []):
function_arn = create_update_lambda(role_arn, component['lambda'])
if __name__ == '__main__':
try:
preflight_checks()
run()
except Exception:
logger.error('preflight checks failed')
|
src/proxy_spider/spiders/xicidaili.py | HaoJiangGuo/fp-server | 173 | 11100804 | <reponame>HaoJiangGuo/fp-server
# -*- coding: utf-8 -*-
from scrapy import Request
from proxy_spider.spiders import _BaseSpider
from utils.collections import shuffled_range
class XicidailiSpider(_BaseSpider):
name = 'xicidaili'
allowed_domains = ['www.xicidaili.com']
def start_requests(self):
for _type in ('nn', 'nt'):
for _page in range(1, 100):
if self.complete_condition():
break
url = 'http://www.xicidaili.com/%s/%s' % (_type, _page)
yield Request(url, dont_filter=True)
def parse(self, response):
for tr in response.xpath('//table[@id="ip_list"]//tr[@class]'):
ex = tr.xpath('./td/text()').extract()
ip = ex[0]
port = ex[1]
scheme = ex[5].lower()
if ip and port and scheme in ('http', 'https'):
yield self.build_check_recipient(ip, port, scheme)
|
alembic/versions/4cd9c1a13771_add_name_origin_sources_uses.py | lmmentel/mendeleev | 105 | 11100846 | """add name origin sources uses
Revision ID: 4cd9c1a13771
Revises: 5a05464c07ae
Create Date: 2017-09-07 11:18:00.919996
"""
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "5a05464c07ae"
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column("elements", sa.Column("name_origin", sa.String))
op.add_column("elements", sa.Column("sources", sa.String))
op.add_column("elements", sa.Column("uses", sa.String))
def downgrade():
with op.batch_alter_table("elements") as batch_op:
batch_op.drop_column("name_origin")
batch_op.drop_column("sources")
batch_op.drop_column("uses")
|
configs/qdtrack-frcnn_r50_fpn_12e_bdd100k_evalseg.py | SysCV/pcan | 271 | 11100860 | _base_ = './qdtrack-frcnn_r50_fpn_12e_bdd100k.py'
# dataset settings
dataset_type = 'BDDVideoDataset'
data_root = 'data/bdd/'
img_norm_cfg = dict(
mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
train_pipeline = [
dict(type='LoadMultiImagesFromFile'),
dict(type='SeqLoadAnnotations', with_bbox=True, with_ins_id=True),
dict(type='SeqResize', img_scale=(1296, 720), keep_ratio=True),
dict(type='SeqRandomFlip', share_params=True, flip_ratio=0.5),
dict(type='SeqNormalize', **img_norm_cfg),
dict(type='SeqPad', size_divisor=32),
dict(type='SeqDefaultFormatBundle'),
dict(
type='SeqCollect',
keys=['img', 'gt_bboxes', 'gt_labels', 'gt_match_indices'],
ref_prefix='ref'),
]
test_pipeline = [
dict(type='LoadImageFromFile'),
dict(
type='MultiScaleFlipAug',
img_scale=(1296, 720),
flip=False,
transforms=[
dict(type='Resize', keep_ratio=True),
dict(type='RandomFlip'),
dict(type='Normalize', **img_norm_cfg),
dict(type='Pad', size_divisor=32),
dict(type='ImageToTensor', keys=['img']),
dict(type='VideoCollect', keys=['img'])
])
]
data = dict(
samples_per_gpu=2,
workers_per_gpu=2,
train=[
dict(
type=dataset_type,
ann_file=data_root + 'labels/seg_track_20/seg_track_train_cocoformat_new.json',
img_prefix=data_root + 'images/seg_track_20/train',
key_img_sampler=dict(interval=1),
ref_img_sampler=dict(num_ref_imgs=1, scope=3, method='uniform'),
pipeline=train_pipeline),
dict(
type=dataset_type,
load_as_video=False,
ann_file=data_root + 'labels/ins_seg/polygons/ins_seg_train_cocoformat.json',
img_prefix=data_root + 'images/10k/train',
pipeline=train_pipeline)
],
val=dict(
type=dataset_type,
ann_file=data_root + 'labels/seg_track_20/seg_track_val_cocoformat.json',
img_prefix=data_root + 'images/seg_track_20/val',
pipeline=test_pipeline),
test=dict(
type=dataset_type,
ann_file=data_root + 'labels/seg_track_20/seg_track_val_cocoformat.json',
img_prefix=data_root + 'images/seg_track_20/val',
pipeline=test_pipeline)) |
python/tests/table_tests/utils.py | azriel1rf/PokerHandEvaluator | 161 | 11100879 | <gh_stars>100-1000
import unittest
from itertools import combinations, combinations_with_replacement, permutations
from phevaluator.hash import hash_quinary
from phevaluator.tables import NO_FLUSH_5
class BaseTestNoFlushTable(unittest.TestCase):
TABLE: list[int] = NotImplemented
VISIT: list[int] = NotImplemented
NUM_CARDS: int = NotImplemented
@classmethod
def setUpClass(cls):
cls.CACHE = []
cls.USED = [0] * 13
cls.QUINARIES = []
cls.CACHE_ADDITIONAL = []
cls.USED_ADDITIONAL = [0] * 13
cls.QUINARIES_ADDITIONAL = []
# Straight Flushes are not in this table
cls.mark_four_of_a_kind()
cls.mark_full_house()
# Flushes are not in this table
cls.mark_straight()
cls.mark_three_of_a_kind()
cls.mark_two_pair()
cls.mark_one_pair()
cls.mark_high_card()
@staticmethod
def quinary_permutations(n):
return permutations(range(13)[::-1], n)
@staticmethod
def quinary_combinations(n):
return combinations(range(13)[::-1], n)
@staticmethod
def quinary_combinations_with_replacement(n):
return combinations_with_replacement(range(13)[::-1], n)
@classmethod
def gen_quinary(cls, ks, cur, additional):
if cur == len(ks):
cls.get_additional(additional)
cls.QUINARIES.append((cls.CACHE[:], cls.QUINARIES_ADDITIONAL[:]))
cls.QUINARIES_ADDITIONAL = []
else:
for i in range(12, -1, -1):
if cls.USED[i] > 0:
continue
cls.CACHE.append(i)
cls.USED[i] = ks[cur]
cls.gen_quinary(ks, cur + 1, additional)
cls.CACHE.pop(-1)
cls.USED[i] = 0
@classmethod
def get_additional(cls, n):
if n == 0:
cls.QUINARIES_ADDITIONAL.append(cls.CACHE_ADDITIONAL[:])
else:
for i in range(12, -1, -1):
if cls.USED[i] + cls.USED_ADDITIONAL[i] >= 4:
continue
cls.CACHE_ADDITIONAL.append(i)
cls.USED_ADDITIONAL[i] += 1
cls.get_additional(n - 1)
cls.CACHE_ADDITIONAL.pop(-1)
cls.USED_ADDITIONAL[i] -= 1
@classmethod
def mark_template(cls, ks):
cls.gen_quinary(ks, 0, cls.NUM_CARDS - 5)
for base, additionals in cls.QUINARIES:
hand = [0] * 13
for i, k in enumerate(ks):
hand[base[i]] = k
base_rank = NO_FLUSH_5[hash_quinary(hand, 5)]
for additional in additionals:
for i in additional:
hand[i] += 1
hash_ = hash_quinary(hand, cls.NUM_CARDS)
for i in additional:
hand[i] -= 1
if cls.VISIT[hash_] > 0:
continue
cls.TABLE[hash_] = base_rank
cls.VISIT[hash_] = 1
cls.QUINARIES = []
@classmethod
def mark_four_of_a_kind(cls):
cls.mark_template((4, 1))
@classmethod
def mark_full_house(cls):
cls.mark_template((3, 2))
@classmethod
def mark_three_of_a_kind(cls):
cls.mark_template((3, 1, 1))
@classmethod
def mark_two_pair(cls):
cls.mark_template((2, 2, 1))
@classmethod
def mark_one_pair(cls):
for paired_card in range(13)[::-1]:
for other_cards in cls.quinary_combinations(cls.NUM_CARDS - 2):
if paired_card in other_cards:
continue
hand = [0] * 13
hand[paired_card] = 2
for i in range(3):
hand[other_cards[i]] = 1
base_hash = hash_quinary(hand, 5)
base_rank = NO_FLUSH_5[base_hash]
for i in range(3, cls.NUM_CARDS - 2):
hand[other_cards[i]] = 1
hash_ = hash_quinary(hand, cls.NUM_CARDS)
if cls.VISIT[hash_] == 0:
cls.VISIT[hash_] = 1
cls.TABLE[hash_] = base_rank
@classmethod
def mark_high_card(cls):
for base in cls.quinary_combinations(cls.NUM_CARDS):
hand = [0] * 13
for i in range(5):
hand[base[i]] = 1
base_hash = hash_quinary(hand, 5)
base_rank = NO_FLUSH_5[base_hash]
for i in range(5, cls.NUM_CARDS):
hand[base[i]] = 1
hash_ = hash_quinary(hand, cls.NUM_CARDS)
if cls.VISIT[hash_] == 0:
cls.VISIT[hash_] = 1
cls.TABLE[hash_] = base_rank
@classmethod
def mark_straight(cls):
hands = []
for lowest in range(9)[::-1]: # From 10 to 2
hand = [0] * 13
for i in range(lowest, lowest + 5):
hand[i] = 1
hands.append(hand)
# Five High Straight Flush
base = [12, 3, 2, 1, 0]
hand = [0] * 13
for i in base:
hand[i] = 1
hands.append(hand)
for hand in hands:
base_rank = NO_FLUSH_5[hash_quinary(hand, 5)]
for additional in cls.quinary_combinations_with_replacement(
cls.NUM_CARDS - 5
):
for i in additional:
hand[i] += 1
hash_ = hash_quinary(hand, cls.NUM_CARDS)
if cls.VISIT[hash_] == 0:
cls.TABLE[hash_] = base_rank
cls.VISIT[hash_] = 1
for i in additional:
hand[i] -= 1
|
problem.py | wangxiaoyunanne/GraphDefense | 140 | 11100891 | <filename>problem.py
#!/usr/bin/env python
"""
problem.py
"""
from __future__ import division
from __future__ import print_function
import os
import sys
import h5py
import cPickle
import numpy as np
from scipy import sparse
from sklearn import metrics
from scipy.sparse import csr_matrix
import torch
from torch.autograd import Variable
from torch.nn import functional as F
# --
# Helper classes
class ProblemLosses:
@staticmethod
def multilabel_classification(preds, targets):
return F.multilabel_soft_margin_loss(preds, targets)
@staticmethod
def classification(preds, targets):
return F.cross_entropy(preds, targets)
@staticmethod
def regression_mae(preds, targets):
return F.l1_loss(preds, targets)
# @staticmethod
# def regression_mse(preds, targets):
# return F.mse_loss(preds - targets)
class ProblemMetrics:
@staticmethod
def multilabel_classification(y_true, y_pred):
y_pred = (y_pred > 0).astype(int)
return {
"micro" : float(metrics.f1_score(y_true, y_pred, average="micro")),
"macro" : float(metrics.f1_score(y_true, y_pred, average="macro")),
}
@staticmethod
def classification(y_true, y_pred):
y_pred = np.argmax(y_pred, axis=1)
return {
"micro" : float(metrics.f1_score(y_true, y_pred, average="micro")),
"macro" : float(metrics.f1_score(y_true, y_pred, average="macro")),
}
# return (y_pred == y_true.squeeze()).mean()
@staticmethod
def regression_mae(y_true, y_pred):
return float(np.abs(y_true - y_pred).mean())
# --
# Problem definition
def parse_csr_matrix(x):
v, r, c = x
return csr_matrix((v, (r, c)))
class NodeProblem(object):
def __init__(self, problem_path, cuda=True):
print('NodeProblem: loading started')
f = h5py.File(problem_path)
self.task = f['task'].value
self.n_classes = f['n_classes'].value if 'n_classes' in f else 1 # !!
self.feats = f['feats'].value if 'feats' in f else None
self.folds = f['folds'].value
self.targets = f['targets'].value
if 'sparse' in f and f['sparse'].value:
self.adj = parse_csr_matrix(f['adj'].value)
self.train_adj = parse_csr_matrix(f['train_adj'].value)
else:
self.adj = f['adj'].value
self.train_adj = f['train_adj'].value
f.close()
self.feats_dim = self.feats.shape[1] if self.feats is not None else None
self.n_nodes = self.adj.shape[0]
self.cuda = cuda
self.__to_torch()
self.nodes = {
"train" : np.where(self.folds == 'train')[0],
"val" : np.where(self.folds == 'val')[0],
"test" : np.where(self.folds == 'test')[0],
}
self.loss_fn = getattr(ProblemLosses, self.task)
self.metric_fn = getattr(ProblemMetrics, self.task)
print('NodeProblem: loading finished')
def __to_torch(self):
if not sparse.issparse(self.adj):
self.adj = Variable(torch.LongTensor(self.adj))
self.train_adj = Variable(torch.LongTensor(self.train_adj))
if self.cuda:
self.adj = self.adj.cuda()
self.train_adj = self.train_adj.cuda()
if self.feats is not None:
self.feats = Variable(torch.FloatTensor(self.feats))
if self.cuda:
self.feats = self.feats.cuda()
def __batch_to_torch(self, mids, targets):
""" convert batch to torch """
mids = Variable(torch.LongTensor(mids))
if self.task == 'multilabel_classification':
targets = Variable(torch.FloatTensor(targets))
elif self.task == 'classification':
targets = Variable(torch.LongTensor(targets))
elif 'regression' in self.task:
targets = Variable(torch.FloatTensor(targets))
else:
raise Exception('NodeDataLoader: unknown task: %s' % self.task)
if self.cuda:
mids, targets = mids.cuda(), targets.cuda()
return mids, targets
def iterate(self, mode, batch_size=512, shuffle=False):
nodes = self.nodes[mode]
idx = np.arange(nodes.shape[0])
if shuffle:
idx = np.random.permutation(idx)
n_chunks = idx.shape[0] // batch_size + 1
for chunk_id, chunk in enumerate(np.array_split(idx, n_chunks)):
mids = nodes[chunk]
targets = self.targets[mids]
mids, targets = self.__batch_to_torch(mids, targets)
yield mids, targets, chunk_id / n_chunks
|
nilmtk/legacy/__init__.py | chandru99/nilmtk | 646 | 11100893 | from . import disaggregate |
lisrd/datasets/hpatches.py | liuyuzhenn/LISRD | 225 | 11100897 | <filename>lisrd/datasets/hpatches.py
""" HPatches dataset. """
import os
import numpy as np
import cv2
import logging
from pathlib import Path
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset
from .base_dataset import BaseDataset
from .utils.data_reader import resize_and_crop
from ..utils.geometry_utils import select_k_best
from ..utils.pytorch_utils import keypoints_to_grid
class Hpatches(BaseDataset):
def __init__(self, config, device):
super().__init__(config, device)
def get_dataset(self, split):
assert split == 'test', 'Only test split supported'
return _Dataset(self._config)
class _Dataset(Dataset):
def __init__(self, config):
self._config = config
root_dir = Path(os.path.expanduser(config['data_path']))
folder_paths = [x for x in root_dir.iterdir() if x.is_dir()]
if len(folder_paths) == 0:
raise ValueError(
f'Could not find any image in folder: {root_dir}.')
logging.info(f'Found {len(folder_paths)} scenes in image folder.')
self._image0_paths = []
self._image1_paths = []
self._homographies = []
for path in folder_paths:
if (config['alteration'] != 'all'
and config['alteration'] != path.stem[0]):
continue
for i in range(2, 7):
self._image0_paths.append(str(Path(path, "1.ppm")))
self._image1_paths.append(str(Path(path, str(i) + '.ppm')))
self._homographies.append(
np.loadtxt(str(Path(path, "H_1_" + str(i)))))
def adapt_homography_to_preprocessing(self, H, img_shape0, img_shape1):
source_size0 = np.array(img_shape0, dtype=float)
source_size1 = np.array(img_shape1, dtype=float)
target_size = np.array(self._config['resize'], dtype=float)
# Get the scaling factor in resize
scale0 = np.amax(target_size / source_size0)
scaling0 = np.diag([1. / scale0, 1. / scale0, 1.]).astype(float)
scale1 = np.amax(target_size / source_size1)
scaling1 = np.diag([scale1, scale1, 1.]).astype(float)
# Get the translation params in crop
pad_y0 = (source_size0[0] * scale0 - target_size[0]) / 2.
pad_x0 = (source_size0[1] * scale0 - target_size[1]) / 2.
translation0 = np.array([[1., 0., pad_x0],
[0., 1., pad_y0],
[0., 0., 1.]], dtype=float)
pad_y1 = (source_size1[0] * scale1 - target_size[0]) / 2.
pad_x1 = (source_size1[1] * scale1 - target_size[1]) / 2.
translation1 = np.array([[1., 0., -pad_x1],
[0., 1., -pad_y1],
[0., 0., 1.]], dtype=float)
return translation1 @ scaling1 @ H @ scaling0 @ translation0
def __getitem__(self, item):
img0_path = self._image0_paths[item]
img0 = cv2.imread(img0_path)
img0 = cv2.cvtColor(img0, cv2.COLOR_BGR2RGB)
img1_path = self._image1_paths[item]
img1 = cv2.imread(img1_path)
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
H = self._homographies[item].astype(float)
if 'resize' in self._config:
H = self.adapt_homography_to_preprocessing(H, img0.shape[:2],
img1.shape[:2])
img0 = resize_and_crop(img0, self._config['resize'])
img1 = resize_and_crop(img1, self._config['resize'])
img_size = img0.shape[:2]
H_inv = np.linalg.inv(H)
img0 = img0.astype(float) / 255.
img1 = img1.astype(float) / 255.
# Extract the keypoints and descriptors of each method
features = {}
for m in self._config['models_name']:
features[m] = {}
feat0 = np.load(img0_path + '.' + m)
feat1 = np.load(img1_path + '.' + m)
# Extract a fixed number of shared keypoints between the images
kp0, mask0 = select_k_best(
feat0['keypoints'][:, [1, 0]], feat0['scores'],
self._config['num_kp'], H, img_size, margin=3)
features[m]['keypoints0'] = kp0
kp1, mask1 = select_k_best(
feat1['keypoints'][:, [1, 0]], feat1['scores'],
self._config['num_kp'], H_inv, img_size, margin=3)
features[m]['keypoints1'] = kp1
# Extract the local descriptors
features[m]['descriptors0'] = feat0['descriptors'][mask0]
features[m]['descriptors1'] = feat1['descriptors'][mask1]
# Extract meta descriptors if they exist
if 'meta_descriptors' in feat0:
meta_desc0_t = torch.tensor(feat0['meta_descriptors'])
grid0 = keypoints_to_grid(torch.tensor(kp0),
img_size).repeat(4, 1, 1, 1)
features[m]['meta_descriptors0'] = F.normalize(F.grid_sample(
meta_desc0_t,
grid0).squeeze(3).permute(2, 0, 1), dim=2).numpy()
meta_desc1_t = torch.tensor(feat1['meta_descriptors'])
grid1 = keypoints_to_grid(torch.tensor(kp1),
img_size).repeat(4, 1, 1, 1)
features[m]['meta_descriptors1'] = F.normalize(F.grid_sample(
meta_desc1_t,
grid1).squeeze(3).permute(2, 0, 1), dim=2).numpy()
return {'image0': img0, 'image1': img1, 'homography': H,
'img0_path': img0_path, 'img1_path': img1_path,
'features': features, 'img_size': img_size}
def __len__(self):
return len(self._homographies) |
asana/resources/webhooks.py | FiyaFly/python-asana | 266 | 11100933 |
from .gen.webhooks import _Webhooks
class Webhooks(_Webhooks):
"""Webhooks resource"""
def create(self, params={}, **options):
"""Establishing a webhook is a two-part process. First, a simple HTTP POST
similar to any other resource creation. Since you could have multiple
webhooks we recommend specifying a unique local id for each target.
Next comes the confirmation handshake. When a webhook is created, we will
send a test POST to the `target` with an `X-Hook-Secret` header as
described in the
[Resthooks Security documentation](http://resthooks.org/docs/security/).
The target must respond with a `200 OK` and a matching `X-Hook-Secret`
header to confirm that this webhook subscription is indeed expected.
If you do not acknowledge the webhook's confirmation handshake it will
fail to setup, and you will receive an error in response to your attempt
to create it. This means you need to be able to receive and complete the
webhook *while* the POST request is in-flight.
Parameters
----------
resource : {Id} A resource ID to subscribe to. The resource can be a task or project.
target : {String} The URL to receive the HTTP POST.
[data] : {Object} Data for the request
"""
return self.client.post("/webhooks", params, **options)
def get_all(self, params={}, **options):
"""Returns the compact representation of all webhooks your app has
registered for the authenticated user in the given workspace.
Parameters
----------
workspace : {Id} The workspace to query for webhooks in.
[params] : {Object} Parameters for the request
- [resource] : {Id} Only return webhooks for the given resource.
"""
return self.client.get_collection("/webhooks", params, **options)
def get_by_id(self, webhook, params={}, **options):
"""Returns the full record for the given webhook.
Parameters
----------
webhook : {Id} The webhook to get.
[params] : {Object} Parameters for the request
"""
path = "/webhooks/%s" % (webhook)
return self.client.get(path, params, **options)
def delete_by_id(self, webhook, params={}, **options):
"""This method permanently removes a webhook. Note that it may be possible
to receive a request that was already in flight after deleting the
webhook, but no further requests will be issued.
Parameters
----------
webhook : {Id} The webhook to delete.
"""
path = "/webhooks/%s" % (webhook)
return self.client.delete(path, params, **options)
|
bentoml/saved_bundle/templates.py | niits/BentoML | 3,451 | 11100937 | # Copyright 2019 Atalaya Tech, Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
BENTO_SERVICE_BUNDLE_SETUP_PY_TEMPLATE = """\
import setuptools
try:
# for pip >= 10
from pip._internal.req import parse_requirements
try:
# for pip >= 20.0
from pip._internal.network.session import PipSession
except ModuleNotFoundError:
# for pip >= 10, < 20.0
from pip._internal.download import PipSession
except ImportError:
# for pip <= 9.0.3
from pip.req import parse_requirements
from pip.download import PipSession
try:
raw = parse_requirements('requirements.txt', session=PipSession())
# pip >= 20.1 changed ParsedRequirement attribute from `req` to `requirement`
install_reqs = []
for i in raw:
try:
install_reqs.append(str(i.requirement))
except AttributeError:
install_reqs.append(str(i.req))
except Exception:
install_reqs = []
setuptools.setup(
name='{name}',
version='{pypi_package_version}',
description="BentoML generated model module",
long_description=\"\"\"{long_description}\"\"\",
long_description_content_type="text/markdown",
url="https://github.com/bentoml/BentoML",
packages=setuptools.find_packages(),
install_requires=install_reqs,
include_package_data=True,
package_data={{
'{name}': ['bentoml.yml', 'artifacts/*']
}},
entry_points={{
'console_scripts': [
'{name}={name}:cli',
],
}}
)
"""
MANIFEST_IN_TEMPLATE = """\
include {service_name}/bentoml.yml
graft {service_name}/artifacts
"""
MODEL_SERVER_DOCKERFILE_CPU = """\
FROM {docker_base_image}
# Configure PIP install arguments, e.g. --index-url, --trusted-url, --extra-index-url
ARG EXTRA_PIP_INSTALL_ARGS=
ENV EXTRA_PIP_INSTALL_ARGS $EXTRA_PIP_INSTALL_ARGS
ARG UID=1034
ARG GID=1034
RUN groupadd -g $GID -o bentoml && useradd -m -u $UID -g $GID -o -r bentoml
ARG BUNDLE_PATH=/home/bentoml/bundle
ENV BUNDLE_PATH=$BUNDLE_PATH
ENV BENTOML_HOME=/home/bentoml/
RUN mkdir $BUNDLE_PATH && chown bentoml:bentoml $BUNDLE_PATH -R
WORKDIR $BUNDLE_PATH
# copy over the init script; copy over entrypoint scripts
COPY --chown=bentoml:bentoml bentoml-init.sh docker-entrypoint.sh ./
RUN chmod +x ./bentoml-init.sh
# Copy docker-entrypoint.sh again, because setup.sh might not exist. This prevent COPY command from failing.
COPY --chown=bentoml:bentoml docker-entrypoint.sh setup.s[h] ./
RUN ./bentoml-init.sh custom_setup
COPY --chown=bentoml:bentoml docker-entrypoint.sh python_versio[n] ./
RUN ./bentoml-init.sh ensure_python
COPY --chown=bentoml:bentoml environment.yml ./
RUN ./bentoml-init.sh restore_conda_env
COPY --chown=bentoml:bentoml requirements.txt ./
RUN ./bentoml-init.sh install_pip_packages
COPY --chown=bentoml:bentoml docker-entrypoint.sh bundled_pip_dependencie[s] ./bundled_pip_dependencies/
RUN rm ./bundled_pip_dependencies/docker-entrypoint.sh && ./bentoml-init.sh install_bundled_pip_packages
# copy over model files
COPY --chown=bentoml:bentoml . ./
# Default port for BentoML Service
EXPOSE 5000
USER bentoml
RUN chmod +x ./docker-entrypoint.sh
ENTRYPOINT [ "./docker-entrypoint.sh" ]
CMD ["bentoml", "serve-gunicorn", "./"]
""" # noqa: E501
INIT_PY_TEMPLATE = """\
import os
import sys
import logging
from bentoml import saved_bundle, configure_logging
from bentoml.cli.bento_service import create_bento_service_cli
# By default, ignore warnings when loading BentoService installed as PyPI distribution
# CLI will change back to default log level in config(info), and by adding --quiet or
# --verbose CLI option, user can change the CLI output behavior
configure_logging(logging_level=logging.ERROR)
__VERSION__ = "{pypi_package_version}"
__module_path = os.path.abspath(os.path.dirname(__file__))
{service_name} = saved_bundle.load_bento_service_class(__module_path)
cli=create_bento_service_cli(__module_path)
def load():
return saved_bundle.load_from_dir(__module_path)
__all__ = ['__version__', '{service_name}', 'load']
"""
|
yellowbrick/datasets/download.py | mrtrkmn/yellowbrick | 3,662 | 11100946 | <reponame>mrtrkmn/yellowbrick<gh_stars>1000+
# yellowbrick.datasets.download
# Downloads the example datasets for running the examples.
#
# Author: <NAME>
# Author: <NAME>
# Author: <NAME>
# Created: Wed May 18 11:54:45 2016 -0400
#
# Copyright (C) 2018 The scikit-yb developers
# For license information, see LICENSE.txt
#
# ID: download.py [1f73d2b] <EMAIL> $
"""
Downloads the example datasets for running the examples.
"""
##########################################################################
## Imports
##########################################################################
import os
import zipfile
from urllib.request import urlopen
from .signature import sha256sum
from .path import get_data_home, cleanup_dataset
from yellowbrick.exceptions import DatasetsError
# Downlod chunk size
CHUNK = 524288
##########################################################################
## Download functions
##########################################################################
def download_data(url, signature, data_home=None, replace=False, extract=True):
"""
Downloads the zipped data set specified at the given URL, saving it to
the data directory specified by ``get_data_home``. This function verifies
the download with the given signature and extracts the archive.
Parameters
----------
url : str
The URL of the dataset on the Internet to GET
signature : str
The SHA 256 hash of the dataset archive being downloaded to verify
that the dataset has been correctly downloaded
data_home : str, optional
The path on disk where data is stored. If not passed in, it is looked
up from YELLOWBRICK_DATA or the default returned by ``get_data_home``.
replace : bool, default: False
If the data archive already exists, replace the dataset. If this is
False and the dataset exists, an exception is raised.
extract : bool, default: True
Extract the archive file after downloading it
"""
data_home = get_data_home(data_home)
# Get the name of the file from the URL
basename = os.path.basename(url)
name, _ = os.path.splitext(basename)
# Get the archive and data directory paths
archive = os.path.join(data_home, basename)
datadir = os.path.join(data_home, name)
# If the archive exists cleanup or raise override exception
if os.path.exists(archive):
if not replace:
raise DatasetsError(
("dataset already exists at {}, set replace=False to overwrite").format(
archive
)
)
cleanup_dataset(name, data_home=data_home)
# Create the output directory if it does not exist
if not os.path.exists(datadir):
os.mkdir(datadir)
# Fetch the response in a streaming fashion and write it to disk.
response = urlopen(url)
with open(archive, "wb") as f:
while True:
chunk = response.read(CHUNK)
if not chunk:
break
f.write(chunk)
# Compare the signature of the archive to the expected one
if sha256sum(archive) != signature:
raise ValueError("Download signature does not match hardcoded signature!")
# If extract, extract the zipfile.
if extract:
zf = zipfile.ZipFile(archive)
zf.extractall(path=data_home)
|
tests/test_claims.py | chhsiao1981/pyoidc | 290 | 11100950 | from oic.oic import claims_match
from oic.utils.claims import ClaimsMode
def test_claims_for_user():
user = "foobar"
user2mode = {user: "aggregate"}
claims_mode = ClaimsMode(user2mode)
assert claims_mode.aggregate(user)
def test_claims_for_missing_user():
claims_mode = ClaimsMode({})
assert not claims_mode.aggregate("nobody")
def test_non_aggregate_claims():
user = "foobar"
claims_mode = ClaimsMode({user: "distributed"})
assert not claims_mode.aggregate(user)
def test_claims_match():
claims_request = {
"sub": {"value": "248289761001"},
"auth_time": {"essential": True},
"acr": {"essential": True,
"values": ["urn:mace:incommon:iap:silver",
"urn:mace:incommon:iap:bronze"]}
}
assert claims_match("248289761001", claims_request['sub'])
assert claims_match("123456789012", claims_request['sub']) is False
assert claims_match("123456789", claims_request['auth_time'])
assert claims_match("urn:mace:incommon:iap:silver", claims_request['acr'])
assert claims_match("urn:mace:incommon:iap:gold",
claims_request['acr']) is False
|
gabbi/tests/test_data_to_string.py | scottwallacesh/gabbi | 145 | 11100978 | #
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Test handling of data field in tests.
"""
import unittest
from gabbi import case
from gabbi import handlers
class TestDataToString(unittest.TestCase):
def setUp(self):
self.case = case.HTTPTestCase('test_request')
self.case.content_handlers = []
for handler in handlers.RESPONSE_HANDLERS:
h = handler()
if hasattr(h, 'content_handler') and h.content_handler:
self.case.content_handlers.append(h)
def testHappyPath(self):
data = [{"hi": "low"}, {"yes": "no"}]
content_type = 'application/json'
body = self.case._test_data_to_string(data, content_type)
self.assertEqual('[{"hi": "low"}, {"yes": "no"}]', body)
def testNoContentType(self):
data = [{"hi": "low"}, {"yes": "no"}]
content_type = ''
with self.assertRaises(ValueError) as exc:
self.case._test_data_to_string(data, content_type)
self.assertEqual(
'no content-type available for processing data',
str(exc.exception))
def testNoHandler(self):
data = [{"hi": "low"}, {"yes": "no"}]
content_type = 'application/xml'
with self.assertRaises(ValueError) as exc:
self.case._test_data_to_string(data, content_type)
self.assertEqual(
'unable to process data to application/xml',
str(exc.exception))
|
example_data/run_sQTL.py | AdaWon/leafcutter | 170 | 11100982 |
import subprocess
def run(cmd, max_minutes = 6000):
import time
sys.stderr.write("Running cmd: %s\n"%cmd)
p = subprocess.Popen(cmd ,
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds=True)
(file_stdin, file_stdout, file_stderr) = (p.stdin, p.stdout, p.stderr)
t = 0
r = ''
e = ''
while t < 60*max_minutes and p.poll() is None:
time.sleep(1) # (comment 1)
t += 1
r += file_stdout.read()
e += file_stderr.read()
r += file_stdout.read()
e += file_stderr.read()
file_stdin.close()
#lines = file_stdout.read()
lines_stderr = file_stderr.read()
exit_code = file_stdout.close()
file_stdout.close()
file_stderr.close()
return (r, e, exit_code)
if __name__ == "__main__":
import sys, os
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-o", "--outprefix", dest="outprefix", default = 'leafcutter',
help="Output prefix (default leafcutter)")
parser.add_option("-t", "--tempdir", dest="tmpdir", default='./tmp/',
help="Where to output files (default ./)")
parser.add_option("-d", "--leafdir", dest="leafd", default='./',
help="Top-level LeafCutter directory")
parser.add_option("-l", "--maxintronlen", dest="maxintronlen", default = 100000,
help="Maximum intron length in bp (default 100,000bp)")
parser.add_option("-m", "--minclureads", dest="minclureads", default = 30,
help="Minimum reads in a cluster (default 30 reads)")
parser.add_option("-p", "--mincluratio", dest="mincluratio", default = 0.001,
help="Minimum fraction of reads in a cluster that support a junction (default 0.001)")
parser.add_option("-a", "--annot", dest="annotation", default = None,
help="[optional] Path of annotation GTF file e.g. ~/tools/leafcutter/clustering/gencode.v19.annotation.gtf.gz")
parser.add_option("-b", "--bams", dest="bam",
help="Text file listing bam files to quantify")
(options, args) = parser.parse_args()
try: open(options.leafd+"/clustering/leafcutter_cluster.py")
except:
sys.stderr.write("Please specify correct LeafCutter directory e.g. -d tools/leafcutter/.\n")
exit(0)
if options.bam == None:
sys.stderr.write("Error: no bam file provided...\n")
exit(0)
bams = open(options.bam).readlines()
# create tmp file directory
try: os.mkdir(options.tmpdir)
except: pass
# (should check if samtools are installed)
sys.stderr.write("processing bam files...\n")
fout = file("%s/junction_files.txt"%options.tmpdir,'w')
for bam in bams:
bam = bam.strip()
bedfile = "%s/%s.bed"%(options.tmpdir,bam.split('/')[-1])
juncfile = "%s/%s.junc"%(options.tmpdir,bam.split('/')[-1])
fout.write(juncfile+'\n')
try: open(juncfile)
except: pass
else:
sys.stderr.write("%s exists..skipping\n"%juncfile)
continue
print run("samtools view %s | python %s/scripts/filter_cs.py | %s/scripts/sam2bed.pl --use-RNA-strand - %s"%(bam, options.leafd, options.leafd,bedfile))[1]
print run("%s/scripts/bed2junc.pl %s %s; rm %s"%(options.leafd,bedfile,juncfile, bedfile))[1]
fout.close()
print run("python %s/clustering/leafcutter_cluster.py -j %s/junction_files.txt -m %s -o %s -l %s -r %s -p %s"%(options.leafd,options.tmpdir,options.minclureads, options.outprefix,str(options.maxintronlen), options.tmpdir,str(options.mincluratio)))[1]
if options.annotation != None:
print run("python %s/clustering/get_cluster_gene.py %s %s/%s_perind.counts.gz"%(options.leafd,options.annotation, options.tmpdir,options.outprefix))[1]
pass
print run("python %s/scripts/prepare_phenotype_table.py %s/%s_perind.counts.gz"%(options.leafd,options.tmpdir,options.outprefix))
sys.stdout.write("\n*******fastQTL instructions (also see http://fastqtl.sourceforge.net/) *******\n")
sys.stdout.write("\n(1) Prepare phenotypes: Use `sh %s/%s_perind.counts.gz_prepare.sh' to create index for fastQTL (requires tabix and bgzip).\n"%(options.tmpdir,options.outprefix))
sys.stdout.write("(2) Prepare covariates: To take the top 5 PCs, use `head -6 %s/%s_perind.counts.gz.PCs > %s/%s_perind.counts.gz.PCs.PC5\n"%(options.tmpdir,options.outprefix,options.tmpdir,options.outprefix))
sys.stdout.write("(3) Prepare genotypes: bgzip + tabix your genotype (VCF) file > SNPs.MAF05.txt.gen.gz (not included)\n")
sys.stdout.write("(4) Run fastQTL: Use e.g. `FastQTL/bin/fastQTL.static --vcf SNPs.MAF05.txt.gen.gz --bed %s/%s_perind.counts.gz.qqnorm_chr1.gz -out %s/%s_output_chr1 --chunk 1 1 --window 1e5 --cov %s/%s_perind.counts.gz.PCs.PC5\n\n\n"%(options.tmpdir,options.outprefix,options.tmpdir,options.outprefix,options.tmpdir,options.outprefix))
|
examples/perl_rockstar.py | hoojaoh/rockstar | 4,603 | 11100997 | from rockstar import RockStar
perl_code = 'print "Hello World"'
rock_it_bro = RockStar(days=400, file_name='hello_world.pl', code=perl_code)
rock_it_bro.make_me_a_rockstar()
|
ISMLnextGen/geventCuncurrencyTest.py | Ravenclaw-OIer/ISML_auto_voter | 128 | 11101006 | <gh_stars>100-1000
import gevent,asyncio
from gevent import monkey
# socket发送请求以后就会进入等待状态，gevent更改了这个机制
# socket.setblocking(False) -->发送请求后就不会等待服务器响应
monkey.patch_all() # 找到内置的socket并更改为gevent自己的东西
import requests
def fetch_async(method, url, req_kwargs,id):
print('started',id, method, url, req_kwargs)
response = requests.request(method=method, url=url, **req_kwargs)
print('finished', id, response.url, len(response.content))
# ##### 发送请求 #####
##gevent.joinall([
## # 这里spawn是3个任务[实际是3个协程]，每个任务都会执行fetch_async函数
## gevent.spawn(fetch_async, method='get', url='https://www.python.org/', req_kwargs={}),
## gevent.spawn(fetch_async, method='get', url='https://www.yahoo.com/', req_kwargs={}),
## gevent.spawn(fetch_async, method='get', url='https://github.com/', req_kwargs={}),
##])
for i in range(100):
gevent.spawn(fetch_async, method='get', url='http://localhost:55556', req_kwargs={},id=i),
loop=asyncio.get_event_loop()
loop.run_forever()
|
python/federatedml/util/schema_check.py | hubert-he/FATE | 3,787 | 11101018 | #
# Copyright 2019 The FATE Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from fate_arch.computing import is_table
from federatedml.util import LOGGER
def check_schema(input_schema, output_schema):
LOGGER.debug(f"input schema: {input_schema} -> output schema: {output_schema}")
if output_schema is None:
raise EnvironmentError(
f"output_schema is None while input data has schema.")
input_header = input_schema.get("header", None)
output_header = output_schema.get("header", None)
if input_header is not None and output_header is None:
raise EnvironmentError(
f"output header is None while input data has header.")
def assert_schema_consistent(func):
def _func(*args, **kwargs):
input_schema = None
all_args = []
all_args.extend(args)
all_args.extend(kwargs.values())
for arg in all_args:
if is_table(arg):
input_schema = arg.schema
break
result = func(*args, **kwargs)
if input_schema is not None:
# single data set
if is_table(result) and result.count() > 0:
output_schema = result.schema
check_schema(input_schema, output_schema)
# multiple data sets
elif type(result).__name__ in ["list", "tuple"]:
for output_data in result:
if is_table(output_data) and output_data.count() > 0:
output_schema = output_data.schema
check_schema(input_schema, output_schema)
return result
return _func
|
hpccm/templates/CMakeBuild.py | robertmaynard/hpc-container-maker | 340 | 11101024 |
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# pylint: disable=invalid-name, too-few-public-methods
"""CMakeBuild template"""
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
from six.moves import shlex_quote
import copy
import posixpath
import hpccm.base_object
class CMakeBuild(hpccm.base_object):
"""Template for cmake workflows"""
def __init__(self, **kwargs):
"""Initialize CMakeBuild template"""
super(CMakeBuild, self).__init__(**kwargs)
self.__build_directory = None
self.cmake_opts = kwargs.get('opts', [])
self.parallel = kwargs.get('parallel', '$(nproc)')
self.prefix = kwargs.get('prefix', '/usr/local')
# Some components complain if some compiler variables are
# enabled, e.g., MVAPICH2 with F90, so provide a way for the
# caller to disable any of the compiler variables.
self.toolchain_control = kwargs.get('toolchain_control',
{'CC': True, 'CXX': True,
'F77': True, 'F90': True,
'FC': True})
def build_step(self, target='all', parallel=None):
"""Generate cmake build command line string"""
if not parallel:
parallel = self.parallel
return 'cmake --build {0} --target {1} -- -j{2}'.format(
self.__build_directory, target, parallel)
def configure_step(self, build_directory='build', directory=None,
environment=[], opts=None, toolchain=None):
"""Generate cmake command line string"""
change_directory = ''
if directory:
src_directory = directory
build_directory = posixpath.join(directory, build_directory)
change_directory = "mkdir -p {0} && cd {0} && ".format(
build_directory)
else:
# Assume the build directory is a subdirectory of the source
# directory and we are already in the build directory
src_directory = '..'
# Cache this for the build step
self.__build_directory = build_directory
e = copy.copy(environment)
if toolchain:
if toolchain.CC and self.toolchain_control.get('CC'):
e.append('CC={}'.format(toolchain.CC))
if toolchain.CFLAGS:
e.append('CFLAGS={}'.format(shlex_quote(toolchain.CFLAGS)))
if toolchain.CPPFLAGS:
e.append('CPPFLAGS={}'.format(shlex_quote(toolchain.CPPFLAGS)))
if toolchain.CXX and self.toolchain_control.get('CXX'):
e.append('CXX={}'.format(toolchain.CXX))
if toolchain.CXXFLAGS:
e.append('CXXFLAGS={}'.format(shlex_quote(
toolchain.CXXFLAGS)))
if toolchain.F77 and self.toolchain_control.get('F77'):
e.append('F77={}'.format(toolchain.F77))
if toolchain.F90 and self.toolchain_control.get('F90'):
e.append('F90={}'.format(toolchain.F90))
if toolchain.FC and self.toolchain_control.get('FC'):
e.append('FC={}'.format(toolchain.FC))
if toolchain.FCFLAGS:
e.append('FCFLAGS={}'.format(shlex_quote(toolchain.FCFLAGS)))
if toolchain.FFLAGS:
e.append('FFLAGS={}'.format(shlex_quote(toolchain.FFLAGS)))
if toolchain.FLIBS:
e.append('FLIBS={}'.format(shlex_quote(toolchain.FLIBS)))
if toolchain.LD_LIBRARY_PATH:
e.append('LD_LIBRARY_PATH={}'.format(shlex_quote(
toolchain.LD_LIBRARY_PATH)))
if toolchain.LDFLAGS:
e.append('LDFLAGS={}'.format(shlex_quote(toolchain.LDFLAGS)))
if toolchain.LIBS:
e.append('LIBS={}'.format(shlex_quote(toolchain.LIBS)))
configure_env = ' '.join(e)
if configure_env:
configure_env += ' '
configure_opts = ''
if not opts and self.cmake_opts:
opts = self.cmake_opts
if opts:
configure_opts = ' '.join(opts)
configure_opts += ' '
if self.prefix:
configure_opts = '-DCMAKE_INSTALL_PREFIX={0:s} {1}'.format(
self.prefix, configure_opts)
cmd = '{0}{1}cmake {2}{3}'.format(
change_directory, configure_env, configure_opts, src_directory)
# Add an annotation if the caller inherits from the annotate template
if callable(getattr(self, 'add_annotation', None)):
self.add_annotation('cmake', '{1}cmake {2}'.format(
change_directory, configure_env, configure_opts,
src_directory).strip())
return cmd.strip() # trim whitespace
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.