def test_instance(self):
Point = recordclass('Point', 'x y')
p = Point(11, 22)
self.assertEqual(p, Point(x=11, y=22))
self.assertEqual(p, Point(11, y=22))
self.assertEqual(p, Point(y=22, x=11))
self.assertEqual(p, Point(*(11, 22)))
self.assertEqual(p, Point(**dict(x=11, y=22)))
self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument
self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument
self.assertEqual(repr(p), 'Point(x=11, y=22)')
#self.assertNotIn('__weakref__', dir(p))
#print(p)
self.assertEqual(p, Point._make([11, 22])) # test _make classmethod
self.assertEqual(p.__attrs__, ('x', 'y')) # test __attrs__ attribute
self.assertEqual(p._replace(x=1), Point(1, 22)) # test _replace method
self.assertEqual(p._asdict(), dict(x=1, y=22)) # test _asdict method
self.assertEqual(vars(p), p._asdict()) # verify that vars() works
p.x = 1
self.assertEqual(p.x, 1)
# verify that field string can have commas
Point = recordclass('Point', 'x, y')
p = Point(x=11, y=22)
self.assertEqual(repr(p), 'Point(x=11, y=22)')
# verify that fieldspec can be a non-string sequence
Point = recordclass('Point', ('x', 'y'))
p = Point(x=11, y=22)
self.assertEqual(repr(p), 'Point(x=11, y=22)')
def test_hash(self):
A = recordclass('A', 'x y', readonly=True)
a = A(1, 2)
hash_a = hash(a)
#self.assertEqual(hash(a), hash(tuple(a)))
B = recordclass('B', 'x y', hashable=True)
b = B(1, 2)
hash_b = hash(b)
#self.assertEqual(hash_b, hash(tuple(b)))
b.x = -1
self.assertNotEqual(hash(b), hash_b)
def test_repr(self):
with support.captured_stdout() as template:
A = recordclass('A', 'x')
self.assertEqual(repr(A(1)), 'A(x=1)')
# repr should show the name of the subclass
class B(A):
pass
self.assertEqual(repr(B(1)), 'B(x=1)')
def test_factory(self):
Point = recordclass('Point', 'x y')
self.assertEqual(Point.__name__, 'Point')
self.assertEqual(Point.__doc__, 'Point(x, y)')
# self.assertEqual(Point.__slots__, ())
self.assertEqual(Point.__module__, __name__)
self.assertEqual(Point.__attrs__, ('x', 'y'))
self.assertRaises(ValueError, recordclass, 'abc%', 'efg ghi') # type has non-alpha char
self.assertRaises(ValueError, recordclass, 'class', 'efg ghi') # type has keyword
self.assertRaises(ValueError, recordclass, '9abc', 'efg ghi') # type starts with digit
self.assertRaises(ValueError, recordclass, 'abc', 'efg g%hi') # field with non-alpha char
self.assertRaises(ValueError, recordclass, 'abc', 'abc class') # field has keyword
self.assertRaises(ValueError, recordclass, 'abc', '8efg 9ghi') # field starts with digit
self.assertRaises(ValueError, recordclass, 'abc', '_efg ghi') # field with leading underscore
self.assertRaises(ValueError, recordclass, 'abc', 'efg efg ghi') # duplicate field
recordclass('Point0', 'x1 y2') # Verify that numbers are allowed in names
recordclass('_', 'a b c') # Test leading underscores in a typename
nt = recordclass('nt', 'the quick brown fox') # check unicode input
self.assertNotIn("u'", repr(nt.__attrs__))
nt = recordclass('nt', ('the', 'quick')) # check unicode input
self.assertNotIn("u'", repr(nt.__attrs__))
self.assertRaises(TypeError, Point._make, [11]) # catch too few args
self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args
def test_name_fixer(self):
for spec, renamed in [
[('efg', 'g%hi'), ('efg', '_1')], # field with non-alpha char
[('abc', 'class'), ('abc', '_1')], # field has keyword
[('8efg', '9ghi'), ('_0', '_1')], # field starts with digit
[('abc', '_efg'), ('abc', '_1')], # field with leading underscore
[('abc', 'efg', 'efg', 'ghi'), ('abc', 'efg', '_2', 'ghi')], # duplicate field
[('abc', '', 'x'), ('abc', '_1', 'x')], # fieldname is a space
]:
self.assertEqual(recordclass('NT', spec, rename=True).__attrs__, renamed)
def _make_recordclass(name, types, readonly=False, hashable=False):
msg = "RecordClass('Name', [(f0, t0), (f1, t1), ...]); each t must be a type"
types = [(n, _type_check(t, msg)) for n, t in types]
rec_cls = recordclass(name, [n for n, t in types], readonly=readonly, hashable=hashable)
rec_cls.__annotations__ = dict(types)
try:
rec_cls.__module__ = _sys._getframe(2).f_globals.get('__name__', '__main__')
except (AttributeError, ValueError):
pass
return rec_cls
def recordclassdef(name, fields, default=None):
r = recordclass(name, fields)
def newNew(_cls):
ff = [default for f in fields]
#print(ff)
return _cls.__old_new(_cls, *ff)
r.__old_new = r.__new__
r.__new__ = newNew
return r
def test_odd_sizes(self):
Zero = recordclass('Zero', '')
self.assertEqual(Zero(), Zero())
self.assertEqual(Zero._make([]), Zero())
self.assertEqual(repr(Zero()), 'Zero()')
self.assertEqual(Zero()._asdict(), {})
self.assertEqual(Zero().__attrs__, ())
Dot = recordclass('Dot', 'd')
self.assertEqual(Dot(1), Dot(1,))
self.assertEqual(Dot._make([1]), Dot(1,))
self.assertEqual(Dot(1).d, 1)
self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
self.assertEqual(Dot(1)._asdict(), {'d':1})
self.assertEqual(Dot(1)._replace(d=999), Dot(999,))
self.assertEqual(Dot(1).__attrs__, ('d',))
# n = 5000
n = 254 # SyntaxError: more than 255 arguments:
import string, random
names = list(set(''.join([random.choice(string.ascii_letters)
for j in range(10)]) for i in range(n)))
n = len(names)
Big = recordclass('Big', names)
b = Big(*range(n))
self.assertEqual(b, Big(*tuple(range(n))))
self.assertEqual(Big._make(range(n)), Big(*tuple(range(n))))
for pos, name in enumerate(names):
self.assertEqual(getattr(b, name), pos)
repr(b) # make sure repr() doesn't blow-up
d = b._asdict()
d_expected = dict(zip(names, range(n)))
self.assertEqual(d, d_expected)
b2 = b._replace(**dict([(names[1], 999),(names[-5], 42)]))
b2_expected = list(range(n))
b2_expected[1] = 999
b2_expected[-5] = 42
self.assertEqual(b2, Big(*tuple(b2_expected)))
self.assertEqual(b.__attrs__, tuple(names))
def test_name_conflicts(self):
# Some names like "self", "cls", "tuple", "itemgetter", and "property"
# failed when used as field names. Test to make sure these now work.
T = recordclass('T', 'itemgetter property self cls tuple')
t = T(1, 2, 3, 4, 5)
self.assertEqual(t, T(1,2,3,4,5))
newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)
self.assertEqual(newt, T(10,20,30,40,50))
# Broader test of all interesting names in a template
with support.captured_stdout() as template:
T = recordclass('T', 'x')
words = set(re.findall('[A-Za-z]+', template.getvalue()))
words -= set(keyword.kwlist)
words = list(words)
if 'None' in words:
words.remove('None')
T = recordclass('T', words)
# test __new__
values = tuple(range(len(words)))
t = T(*values)
self.assertEqual(t, T(*values))
t = T(**dict(zip(T.__attrs__, values)))
self.assertEqual(t, T(*values))
# test _make
t = T._make(values)
self.assertEqual(t, T(*values))
# exercise __repr__
repr(t)
# test _asdict
self.assertEqual(t._asdict(), dict(zip(T.__attrs__, values)))
# test _replace
t = T._make(values)
newvalues = tuple(v*10 for v in values)
newt = t._replace(**dict(zip(T.__attrs__, newvalues)))
self.assertEqual(newt, T(*newvalues))
# test __attrs__
self.assertEqual(T.__attrs__, tuple(words))
def test_defaults(self):
Point = recordclass('Point', 'x y', defaults=(10, 20)) # 2 defaults
self.assertEqual(Point(1, 2), Point(1, 2))
self.assertEqual(Point(1), Point(1, 20))
self.assertEqual(Point(), Point(10, 20))
Point = recordclass('Point', 'x y', defaults=(20,)) # 1 default
self.assertEqual(Point(1, 2), Point(1, 2))
self.assertEqual(Point(1), Point(1, 20))
Point = recordclass('Point', 'x y', defaults=()) # 0 defaults
self.assertEqual(Point(1, 2), Point(1, 2))
with self.assertRaises(TypeError):
Point(1)
with self.assertRaises(TypeError): # catch too few args
Point()
with self.assertRaises(TypeError): # catch too many args
Point(1, 2, 3)
with self.assertRaises(TypeError): # too many defaults
Point = recordclass('Point', 'x y', defaults=(10, 20, 30))
with self.assertRaises(TypeError): # non-iterable defaults
Point = recordclass('Point', 'x y', defaults=10)
with self.assertRaises(TypeError): # another non-iterable default
Point = recordclass('Point', 'x y', defaults=False)
Point = recordclass('Point', 'x y', defaults=None) # default is None
self.assertIsNone(Point.__new__.__defaults__, None)
self.assertEqual(Point(10, 20), Point(10, 20))
with self.assertRaises(TypeError): # catch too few args
Point(10)
Point = recordclass('Point', 'x y', defaults=[10, 20]) # allow non-tuple iterable
self.assertEqual(Point.__new__.__defaults__, (10, 20))
self.assertEqual(Point(1, 2), Point(1, 2))
self.assertEqual(Point(1), Point(1, 20))
self.assertEqual(Point(), Point(10, 20))
Point = recordclass('Point', 'x y', defaults=iter([10, 20])) # allow plain iterator
self.assertEqual(Point.__new__.__defaults__, (10, 20))
self.assertEqual(Point(1, 2), Point(1, 2))
self.assertEqual(Point(1), Point(1, 20))
self.assertEqual(Point(), Point(10, 20))
def test_tupleness(self):
Point = recordclass('Point', 'x y')
p = Point(11, 22)
self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple
self.assertEqual(list(p), [11, 22]) # coercable to a list
self.assertEqual(max(p), 22) # iterable
self.assertEqual(max(*p), 22) # star-able
x, y = p
self.assertEqual(tuple(p), (x, y)) # unpacks like a tuple
self.assertEqual((p[0], p[1]), (11, 22)) # indexable like a tuple
self.assertRaises(IndexError, p.__getitem__, 3)
self.assertEqual(p.x, x)
self.assertEqual(p.y, y)
self.assertRaises(AttributeError, eval, 'p.z', locals())
def __new__(cls, name, parents, dct):
state_vars = dct.get('state_vars', [])
behaviors = dct.get('behaviors', [])
dct['State'] = recordclass('{}State'.format(name), state_vars)
# extract vars required by behaviors
# can handle partials as well
all_required_vars = set(sum((
b.required_vars if not isinstance(b, partial)
else b.func.required_vars
for b in behaviors
), []))
missing = [var for var in all_required_vars
if var not in state_vars]
if missing:
raise MissingVarError('required vars {} are missing in agent `state_vars`'.format(missing))
return type.__new__(cls, name, parents, dct)
#!/usr/bin/python3
import struct
from recordclass import recordclass
from pyxenoverse import BaseRecord, merge_dict
BACEntry = recordclass(
'BACEntry',
['flags', 'num_sub_entries', 'unk_06', 'sub_entry_offset', 'unk_0C'])
BAC_ENTRY_SIZE = 16
BAC_ENTRY_BYTE_ORDER = 'IHHII'
class Entry(BaseRecord):
def __init__(self, bac, index):
super().__init__()
self.bac = bac
self.index = index
self.sub_entries = []
self.data = BACEntry(*([0] * len(BACEntry.__fields__)))
self.flags = 0x80000000
def read(self, f, endian):
self.data = BACEntry(
*struct.unpack(endian +
BAC_ENTRY_BYTE_ORDER, f.read(BAC_ENTRY_SIZE)))
# self.flags = self.flags & 0xF if self.num_sub_entries > 0 else (self.flags & 0x0F) | 0x80000000
def write(self, f, sub_entry_offset, item_offset, endian):
self.sub_entries.sort(key=lambda n: n.type)
self.num_sub_entries = len(self.sub_entries)
"""Unit tests for recordclass.py."""
import unittest, doctest, operator
from recordclass import recordclass
from collections import OrderedDict
import pickle, copy
import keyword
import re
import sys
try:
from test import support
except:
from test import test_support as support
TestNT = recordclass('TestNT', 'x y z') # type used for pickle tests
class RecordClassTest(unittest.TestCase):
def test_factory(self):
Point = recordclass('Point', 'x y')
self.assertEqual(Point.__name__, 'Point')
self.assertEqual(Point.__doc__, 'Point(x, y)')
# self.assertEqual(Point.__slots__, ())
self.assertEqual(Point.__module__, __name__)
self.assertEqual(Point.__attrs__, ('x', 'y'))
self.assertRaises(ValueError, recordclass, 'abc%', 'efg ghi') # type has non-alpha char
self.assertRaises(ValueError, recordclass, 'class', 'efg ghi') # type has keyword
self.assertRaises(ValueError, recordclass, '9abc', 'efg ghi') # type starts with digit
# convert to lower case
stripped = [w.lower() for w in stripped]
# remove stop words
stop_words = set(stopwords.words('english'))
stop_words.add("")
words = [w for w in stripped if not w in stop_words]
# lemmatize
lemma_function = WordNetLemmatizer()
mod_tokens = [lemma_function.lemmatize(tok) for tok in words]
return mod_tokens
posting = recordclass('posting', 'term_freq doc_id')
posting_list = recordclass('posting_list', 'doc_freq postings')
def add_tokens(iindex, tokens, doc_id):
tf = {}
for tok in tokens:
if tok not in tf:
tf[tok] = 0
tf[tok] += 1
for (k, term_freq) in tf.items():
if k not in iindex:
iindex[k] = posting_list(0, [])
iindex[k].postings.append(posting(term_freq, doc_id))
iindex[k].doc_freq += 1
right_on=('name', 'email'),
how='left')['actor_id']
committer = pd.merge(
cf, af, left_on=actor_columns[2:],
right_on=('name', 'email'),
how='left')['actor_id']
commit_frame.insert(3, 'author', author)
commit_frame.insert(4, 'committer', committer)
if drop_name_email:
commit_frame.drop(actor_columns, axis=1, inplace=True)
return commit_frame
PARSED_EMAIL_FIELDS = ['email', 'valid', 'name', 'domain', 'parsed_name']
ParsedEmail = recordclass('ParsedEmail', PARSED_EMAIL_FIELDS)
PARSED_NAME_FIELDS = ['name', 'name_type']
ParsedName = recordclass('ParsedName', PARSED_NAME_FIELDS)
def proper(name: ParsedName):
return name.name_type == 'proper' or name.name_type == 'personal'
class Actor:
name: str
email: str
actor_id: str
parsed_email: ParsedEmail
import pygame
import pygame.gfxdraw
from recordclass import recordclass
from colors import *
from shapes import *
from fonts import *
XYPoint = recordclass("XYPoint", "x y")
class Screen:
def __init__(self, screen, scoreTracker):
self.__screen = screen
self.__scoreTracker = scoreTracker
self.__headerHeight = 160
self.__margin = 10
self.__lastTotalArea = 0, 0, 0, 0
self.__lastPlayerCountAreas = [(0, 0, 0, 0), (0, 0, 0, 0)]
self.__lastPlayerScoreAreas = [(0, 0, 0, 0), (0, 0, 0, 0)]
self.__lastPlayerTotalScoreAreas = [(0, 0, 0, 0), (0, 0, 0, 0)]
self._register_components()
self._prerender()
def _register_components(self):
self.__logo = pygame.image.load("images/logo.png").convert_alpha()
self.__headerLbl = HEADER_FONT.render("ENTS Plinko", 1, PRIMARY_HEADER_TEXT_COLOR)
def _prerender(self):
self.__screen.fill(BACKGROUND_COLOR)
sr = self.__screen.get_rect()
class IncomeStatement:
Revenue = recordclass('Revenue', 'salaries bonuses capital_gains')
EbitExpenses = recordclass(
'EbitExpenses',
'o_and_a deductions education a_and_m discretionary debts')
ItExpenses = recordclass('ItExpenses', 'interest taxes')
Expenses = recordclass('Expenses', 'ebit it')
def __init__(self, beginning, ending):
self.beginning = beginning
self.ending = ending
self.revenue = self.Revenue(Decimal(0), Decimal(0), Decimal(0))
self.expenses = self.Expenses(
self.EbitExpenses(Decimal(0), Decimal(0), Decimal(0), Decimal(0),
Decimal(0), Decimal(0)),
self.ItExpenses(Decimal(0), Decimal(0)),
)
self.cc_transactions = {}
def add_paystub(self, paystub):
pay_period = paystub.pay_period
paystub = paystub.current
if not is_date_between(
date=pay_period.end, start=self.beginning, end=self.ending):
return
self.revenue.salaries += paystub.earnings.wages
self.revenue.bonuses += paystub.earnings.bonuses
self.expenses.ebit.deductions -= paystub.deductions.total
self.expenses.it.taxes -= paystub.taxes.total
def add_timed_liability(self, liability):
self.expenses.ebit.o_and_a -= liability.amount_from(
self.beginning, self.ending)
def add_cc_statement(self, statement):
for transaction in statement.transactions:
if is_date_between(
transaction.date, self.beginning, self.ending
) and transaction.id not in self.cc_transactions:
self.cc_transactions[transaction.id] = transaction
if transaction.in_category(Automotive):
self.expenses.ebit.o_and_a += transaction.amount
elif transaction.in_category(Education):
self.expenses.ebit.education += SemesterAccrualBasis(
transaction.amount,
transaction.date).accrued(self.beginning, self.ending)
elif transaction.in_category(Entertainment):
self.expenses.ebit.discretionary += transaction.amount
elif transaction.in_category(Food):
self.expenses.ebit.o_and_a += transaction.amount
elif transaction.in_category(Luxuries):
self.expenses.ebit.discretionary += transaction.amount
elif transaction.in_category(Medical):
self.expenses.ebit.o_and_a += transaction.amount
elif transaction.in_category(Utilities):
self.expenses.ebit.o_and_a += transaction.amount
else:
self.expenses.ebit.discretionary += transaction.amount
@property
def revenue_total(self):
return sum([source for source in self.revenue])
@property
def ebit_expenses(self):
return sum([source for source in self.expenses.ebit])
@property
def it_expenses(self):
return sum([source for source in self.expenses.it])
@property
def expenses_total(self):
return sum([self.ebit_expenses, self.it_expenses])
@property
def operating_income(self):
return self.revenue_total + self.ebit_expenses # expenses are negative, so really revenue - expenses
@property
def net_income(self):
return self.revenue_total + self.expenses_total # expenses are negative, so really revenue - expenses
def to_table(self):
tables = [
[
['Income Statement', 'for period'],
['Beginning', self.beginning],
['Ending', self.ending],
],
[['Revenue']],
[
['Salaries', self.revenue.salaries],
['Bonuses', self.revenue.bonuses],
['Realized Capital Gains', self.revenue.capital_gains],
['Total', self.revenue_total],
],
[['Expenses']],
[
['Operating and Administrative', self.expenses.ebit.o_and_a],
['Deductions', self.expenses.ebit.deductions],
['Education', self.expenses.ebit.education],
['Acquisition and Maintenence', self.expenses.ebit.a_and_m],
['Discretionary', self.expenses.ebit.discretionary],
['Creditor Obligations', self.expenses.ebit.debts],
['Total', self.ebit_expenses],
],
[['Operating Income (EBIT)', self.operating_income]],
[['Interest Expense', self.expenses.it.interest],
['Income Tax Expense', self.expenses.it.taxes],
['Total', self.it_expenses]],
[['Net Income', self.net_income]],
]
formatted_tables = ''
for table in tables:
formatted_tables += tabulate(table,
tablefmt='fancy_grid',
floatfmt='.2f',
headers='firstrow') + '\n\n'
return formatted_tables
from codemend import BackupHandler, relative_path
from codemend.models.baseline2 import Baseline, Context, RandomBaseline, SuggestItem
from codemend.models.element import ElementNormalizer
from codemend.models.element_extract import extract_varmap_elems
from codemend.models.word2vec_baseline2 import Word2vecBaseline
from codemend.models.bimodal_baseline2 import BiModalBaseline
from codemend.models.bimodal2 import BiModal # to make pickler happy
ResultLogEntry = recordclass('ResultLogEntry',
['code_sample_idx',
'query',
'baseline',
'candidate',
'rank',
'is_gt', # 1 or 0
'score',
'answer_rank',
'answer',
])
class EvalBrain:
def __init__(self):
self.expected_set_cache = {}
self.queries = []
# load the ground-truth file
with open('eval-gt-2.csv', 'rb') as csv_file:
reader = csv.reader(csv_file)
# columns:
import argparse
import time
from recordclass import recordclass
import pdb
import numpy
import obj_reader
import texture
import seam_erasure
from util import to_uint8
from lib import weight_data
InputTextureFile = recordclass("InputTextureFile",
["name", "depth", "isFloat", "isDataFile"])
def create_parser():
""" Creates an ArgumentParser for this command line tool. """
parser = argparse.ArgumentParser(
description="Erase texture seams to " +
"prevent visible seams or tearing in various texture maps (color, " +
"normal, displacement, ambient occlusion, etc.)",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
usage="%(prog)s path/to/input_model path/to/input_texture [-h] " +
"[-o path/to/output_texture] [-g] [--sv {none,texture,lerp}] [-d]")
parser.add_argument("in_mesh",
metavar="path/to/input_model",
help="Path to input mesh file.")
parser.add_argument(
from collections import defaultdict
from recordclass import recordclass
from src.common import storage, Ptw, Bar, extract_sublist
from src.common.math import percentage, percentage_str
# stores number of cases
# key was/was not found in storage when command was executed
CmdKeyCases = recordclass('CmdFound', 'key_existed, key_null')
class CommandPercentage:
"""Computes number of command occurrences
and their percentage from total lines."""
def __init__(self):
# {cmd: CmdKeyCases}
self.cases = defaultdict(lambda: CmdKeyCases(0, 0))
self.hashloads = 0
self.wtab = None
def comp_ALRS(self, line):
if storage[line.key]:
self.cases[line.cmd].key_existed += 1
else:
self.cases[line.cmd].key_null += 1
def comp_H(self, line):
self.hashloads += 1
def _create_wtab(self):
if self.wtab is not None:
return
total = self.hashloads
for key in self.cases:
total += self.cases[key].key_existed + self.cases[key].key_null
# sortby ocs, max first, center first column, rest align to right
import torch as t
from recordclass import recordclass
tensor_cache = {}
Vector = recordclass('Vector', 'x y')
def manhattan(a, b):
return abs(a.x - b.x) + abs(a.y - b.y)
def to_one_hot(index, n_classes):
return tensor_cache['{}_{}'.format(index, n_classes)]
for n_classes in range(1, 20):
for i in range(n_classes):
onehot = t.zeros(n_classes)
onehot.scatter_(0, t.tensor(i), 1)
tensor_cache['{}_{}'.format(i, n_classes)] = onehot
from recordclass import recordclass
from pyxenoverse.bac.types import BaseType
BACTransparencyEffect = recordclass('BACTransparencyEffect', [
'start_time', 'duration', 'u_04', 'character_type', 'transparency_flags',
'transparency_flags2', 'dilution', 'u_0e', 'u_10', 'red', 'green', 'blue',
'f_20', 'f_24', 'f_28', 'f_2c', 'f_30', 'f_34', 'f_38', 'f_3c'
])
# Type 23
class TransparencyEffect(BaseType):
type = 23
bac_record = BACTransparencyEffect
byte_order = 'HHHHHHHHIfffffffffff'
size = 64
def __init__(self, index):
super().__init__(index)
self.color = [0, 0, 0]
def read(self, f, endian, _):
super().read(f, endian, _)
self.red = int(self.red * 255.0)
self.green = int(self.green * 255.0)
self.blue = int(self.blue * 255.0)
self.color = [self.red, self.green, self.blue]
def write(self, f, endian):
self.red, self.green, self.blue = self.color
""" orderbook as module contains the configuration parameters and the class Orderbook
that expose the functional of adding,updating and cancelling and order and retrieving
the best of ask and bid orders"""
from collections import defaultdict
from recordclass import recordclass
DEC = 5
ASK = "S"
BID = "B"
CANCEL = "c"
UPDATE = "u"
ADD = "a"
Order = recordclass(
'Order', ['order_id', 'timestamp', 'ticker', 'side', 'price', 'size'])
class OrderBook:
""" OrderBook its a data structure that keep track of the orders inserted on multiple
tickers and on both bid and ask side of the book"""
def __init__(self):
self.orders_dict = {}
self.max_bid = defaultdict(int)
self.min_ask = defaultdict(int)
def _cancel(self, order_id: str):
""" cancel keeps memory of side,price,and ticker, delete the order and
search for a new min or max in the only case the order was on its side frontier"""
order_tmp = self.orders_dict[order_id]
del self.orders_dict[order_id]
# Liar's Dice game bot
# Matthew Kroesche
import discord
import recordclass
import random
import asyncio
from .game import Game
Player = recordclass.recordclass('Player', 'user dice bid passed')
# user: the discord.User controlling this player.
# dice: the list of die rolls of this player
# bid: either None or a 2-tuple (number, value)
# passed: boolean indicating whether the player has passed this round
PASS_NONE = 0 # Passing not allowed
PASS_TWO = 1 # Passing allowed if there are exactly two dice showing different values
PASS_UNIQUE = 2 # Passing allowed if no two dice show the same value
PASS_SKIP = 4 # Passing only allowed if the player before you didn't also pass
SPOT_NONE = 0 # Spot not allowed
SPOT_NORMAL = 1 # Spot allowed
SPOT_REWARD = 2 # A correct spot call gives you a die back (or takes one away in backwards games)
SPOT_PENALIZE = 4 # A correct spot call causes everyone else to lose a die (or gain one in backward games)
# Default settings for pass and spot
PASS_DEFAULT = PASS_UNIQUE
SPOT_DEFAULT = SPOT_PENALIZE
RESULT_DELAY = 10 # Number of seconds before dice messages are deleted
import random
import subprocess
import signal
import os
import math
import random
from time import sleep
from tf.transformations import euler_from_quaternion
#from collections import namedtuple
from recordclass import recordclass
position = None
lidar = None
collision = False
debug_info = recordclass('extra_info', "dist collisions goal".split())
def update_position(data):
global position
position = (data.pose.pose.position.x, data.pose.pose.position.y)
def update_lidar(data):
global lidar
lidar = data.ranges
def set_collision(data):
global collision
#print("Collided")
class WaterDetectionStatus(Enum):
UNKNOWN_ERROR = -1
MEASUREMENT_VALID = 1
INVALID_DATA = 2
TOO_CLOUDY = 3
SH_REQUEST_ERROR = 4
SH_NO_DATA = 5
SH_NO_CLOUD_DATA = 6
INVALID_POLYGON = 7
Measurement = recordclass('SurfaceWaterLevelMeasurement', [
'BLUEDOT_WB_ID', 'BLUEDOT_MEAS_DATE', 'SAT_IMAGE_DATE', 'SENSOR_TYPE',
'MEAS_STATUS', 'MEAS_ALG_VER', 'CLOUD_COVERAGE', 'SURF_WATER_LEVEL',
'CC_ORIG', 'CC_CLEAN', 'ALG_STATUS', 'GEOMETRY', 'S3_IMAGE_URL'
])
def get_new_measurement_entry(dam_id, date, sensor, version):
return Measurement(BLUEDOT_WB_ID=dam_id,
BLUEDOT_MEAS_DATE=datetime.today().strftime('%Y-%m-%d'),
SAT_IMAGE_DATE=date.strftime('%Y-%m-%d'),
SENSOR_TYPE=sensor.value,
MEAS_STATUS=WaterDetectionStatus.UNKNOWN_ERROR.value,
MEAS_ALG_VER=version,
CLOUD_COVERAGE=1.0,
SURF_WATER_LEVEL=0.0,
CC_ORIG=0,
CC_CLEAN=0,
* Author(s): Melissa LeBlanc-Williams
"""
from recordclass import recordclass
from PIL import Image
from displayio.bitmap import Bitmap
from displayio.colorconverter import ColorConverter
from displayio.ondiskbitmap import OnDiskBitmap
from displayio.shape import Shape
from displayio.palette import Palette
__version__ = "0.0.0-auto.0"
__repo__ = "https://github.com/adafruit/Adafruit_Blinka_displayio.git"
Rectangle = recordclass("Rectangle", "x1 y1 x2 y2")
Transform = recordclass("Transform",
"x y dx dy scale transpose_xy mirror_x mirror_y")
# pylint: disable=too-many-instance-attributes
class TileGrid:
"""Position a grid of tiles sourced from a bitmap and pixel_shader combination. Multiple
grids can share bitmaps and pixel shaders.
A single tile grid is also known as a Sprite.
"""
def __init__(self,
bitmap,
*,
pixel_shader,
replays = []
for name in files:
replay = osr.read_file(name, flip)
replays.append(replay)
replays.sort()
n = len(replays)
for r in replays:
print('%2d. %15s - %d' % (n, r.player, r.score))
n -= 1
print('read %d replays' % len(replays))
State = recordclass('State', 'replay color x y z trail')
states = []
for replay in replays:
# we don't need anything else on the replay object so remove the references
replay = replay.replay
color = WHITE if len(replays) == 1 else pick_color()
states.append(State(replay, color, 0, 0, 0, deque()))
del replays
HEIGHT = 768
WIDTH = 1366
KEYSIZE = min((WIDTH-1024)/5, HEIGHT / len(states))
def scale(x, y):
class Interface(Frame):
def __init__(self, title="Window", width=300, height=200):
# init gui #
# create main window
self._master = Tk()
# set its size
self._master.geometry(str(width) + "x" + str(height))
# set its title
self._master.title(title)
# init
Frame.__init__(self, self._master)
# Selected_Point
SelectedPoint = recordclass('SelectedPoint', 'index point distance_from_click')
# Primitive
Primitive = recordclass('Primitive', 'num_primitive num_frame')
class Window(Interface):
# window size
_width = 1920
_width_button = 8
_height = 1080
_height_button = 2
def __init__(self, datasets=None):
# check
if not isinstance(datasets, dict):
with CsvWriter(obj.directory, DocumentSimilarity) as out:
distances = squareform(pdist(theta.T, 'cosine'))
out << (dict(a_id=i,
b_id=sim_i,
similarity=1 - row[sim_i])
for i, row in enumerate(distances)
for sim_i in row.argsort()[:31] # first 30 similar docs
if sim_i != i)
with CsvWriter(obj.directory, TopicSimilarity) as out:
distances = squareform(pdist(phi.T, 'cosine'))
out << (dict(a_id=topic_id(1, i),
b_id=topic_id(1, sim_i),
similarity=1 - row[sim_i])
for i, row in enumerate(distances)
for sim_i in row.argsort()[:]
if sim_i != i)
with CsvWriter(obj.directory, TermSimilarity) as out:
distances = squareform(pdist(phi, 'cosine'))
out << (dict(a_modality_id=1, a_id=i,
b_modality_id=1, b_id=sim_i,
similarity=1 - row[sim_i])
for i, row in enumerate(distances)
for sim_i in row.argsort()[:21] # first 20 similar terms
if sim_i != i)
if __name__ == '__main__':
cli(obj=recordclass('Obj', 'directory')(directory=None))
from collections import defaultdict
import matplotlib.pyplot as plt
from recordclass import recordclass
from src.common import COMMANDS
# total_ocs - stores current total occurrences of command
# samples - list of samples of total_ocs taken at times of sampling
# these are used as y-values on a graph
CmdSample = recordclass('CmdSample', 'total_ocs, samples')
class CommandTimeline:
"""Computes changes in number of occurrences of commands over time."""
def __init__(self, lines_sample=500):
"""Args:
lines_sample (int) opt: Splits graph into sections
each containing this number of lines.
"""
self.lines_sample = max([lines_sample, 1])
self.next_sample = 1
# {cmd: list of occurrences at the time}
self.y_cmd = defaultdict(lambda: CmdSample(0, []))
self.x_time = []
def _create_sample(self, line_num):
for cmd in COMMANDS:
csample = self.y_cmd[cmd]
csample.samples.append(csample.total_ocs)
self.x_time.append(line_num)
def comp_all_timeline(self, line):
#!/usr/bin/env python
import random
import time
import psutil
import os
from recordclass import recordclass
def memory_usage_psutil():
# return the memory usage in percentage like top
process = psutil.Process(os.getpid())
mem = process.memory_percent()
return mem
X = recordclass('x', ['a','b','c'])
while True:
a = X(str(random.randint(1000000,10000000)), random.randint(1,1000),
'a' * random.randint(1,1024))
del a
time.sleep(.01)
print(memory_usage_psutil())
"""
import sys
import re
from typing import Dict, Any
from recordclass import recordclass
_items = ['institution',
'title',
'award',
'hegis',
'first_registration_date',
'last_registration_action',
'tap', 'apts', 'vvta',
'certificate_license',
'accreditation']
_variant_info = recordclass('Variant_Info', _items, mapping=True)
class Program(object):
""" For each program registered with NYS Department of Education, collect information about the
program scraped from the DoE website.
Some programs appear more than once, so a class list of programs instances prevents duplicate
entries.
A single program can have multiple variants, which differ in title, institution, award, and/or
hegis. Emprically, no two variants share the same {award, hegis, and institution} combination,
so that tuple is used as the key for a dictionary of per-variant values. All variants of a
program share a single program code and unit code.
Variant details are maintained as a recordclass so the values can be updated as new records
import numpy
from sklearn.cluster import KMeans
from recordclass import recordclass
import pickle
Log = recordclass('Log', ['coin', 'value_ask', 'value_bid'])
# classes
class SuperQueue:
def __init__(self, dim):
self.items = []
self.dim = dim
def put(self, el):
if len(self.items) == self.dim:
self.items = self.items[1 :]
self.items.append(el)
def clear(self):
del self.items[:]
self.dim = 0
def changeSize(self, dim):
self.dim = dim
def show(self):
print(self.items)
# functions
import json
import pickle
import string
import nltk
import re
import math
from collections import defaultdict
from bs4 import BeautifulSoup
from bs4.element import Comment
from recordclass import recordclass
# creates the Posting class
# identical to namedtuple, except it is mutable. This is useful for the rescoring of the
# tf-idf scores of old postings
Posting = recordclass("Posting", ["docId", "tf", "tfidf"])
class indexCreator:
def __init__(self, webFilesPath, indexPath):
self.webFilesPath = webFilesPath
self.indexPath = indexPath
self.invertedIndex = defaultdict(list)
def createIndex(self):
self._traverseDirectory()
self._calculateScores()
self._serializeIndex()
def _openJsonFile(self):
"""
ArticleSubjectTerms -> subjectTerms : 10
JournalTitle -> pubtitle : 5
JournalDate -> pubdate : 4
# JournalCountry -> publisher : 20
JournalIssue -> issue : 7
JournalVolume -> volume : 8
JournalYear -> year : 6
"""
ColumnMap = {
"ArticleTitle": 0,
"ArticleAuthors": 2,
# "ArticleCorrespondenceAuthor": 7,
"ArticleAbstract": 1,
"ArticleSubjectTerms": 10,
"JournalTitle": 5,
"JournalDate": 4,
# "JournalCountry": 20,
"JournalIssue": 7,
"JournalVolume": 8,
"JournalYear": 6
}
"""
The JournalEntry named tuple holds a single publication record.
"""
JournalEntry = recordclass("JournalEntry", "ArticleTitle ArticleAuthors \
ArticleAbstract ArticleSubjectTerms JournalTitle \
JournalDate JournalIssue JournalVolume \
JournalYear")
class OmringaGameState(GameState):
class State(Enum):
BET = 0
NATURE = 1
PLACE = 2
Change = recordclass('Change', 'player state bets passes chosen_player pass_ position index')
def __init__(self):
super().__init__(2, (7, 7), 3, 0)
self.min_bet = 0
self.max_bet = 9
self.group_penalty = -5
self.state = OmringaGameState.State.BET
self.bets = (None, None)
self.passes = 0
self.chosen_player = None
self.board_ = np.zeros(self.board_shape, np.float32)
self.empty_positions = [
(y, x)
for y in range(self.board_shape[0])
for x in range(self.board_shape[1])]
self.changes = []
def move_count(self):
if self.state == OmringaGameState.State.BET:
return self.max_bet - self.min_bet
elif self.state == OmringaGameState.State.NATURE:
return 2
else:
if self.passes == 2:
return 0
else:
return len(self.empty_positions) + 1
def apply_move(self, move):
change = OmringaGameState.Change(
player=self.player,
state=self.state,
bets=self.bets,
passes=self.passes,
chosen_player=self.chosen_player,
pass_=None,
position=None,
index=None)
self.changes.append(change)
if self.state == OmringaGameState.State.BET:
self.bets = (
move if self.player == 0 else self.bets[0],
move if self.player == 1 else self.bets[1])
if self.bets[self.player ^ 1] is None:
self.state = OmringaGameState.State.BET
self.player ^= 1
else:
if self.bets[0] == self.bets[1]:
self.state = OmringaGameState.State.NATURE
self.player = -1
else:
self.state = OmringaGameState.State.PLACE
self.player = 1 if self.bets[0] < self.bets[1] else 0
elif self.state == OmringaGameState.State.NATURE:
self.state = OmringaGameState.State.PLACE
self.player = move
self.chosen_player = move
else:
if move == len(self.empty_positions):
change.pass_ = True
self.state = OmringaGameState.State.NATURE
self.player ^= 1
self.passes += 1
else:
change.pass_ = False
change.position = self.empty_positions[move]
change.index = move
self.board_[change.position[0], change.position[1]] = self.player + 1
self.empty_positions[move], self.empty_positions[-1] = \
self.empty_positions[-1], self.empty_positions[move]
self.empty_positions.pop()
def undo_move(self):
change = self.changes.pop()
self.player = change.player
self.state = change.state
self.bets = change.bets
self.passes = change.passes
self.chosen_player = change.chosen_player
if self.state == OmringaGameState.State.PLACE:
if not change.pass_:
self.empty_positions.append(change.position)
self.empty_positions[change.index], self.empty_positions[-1] = \
self.empty_positions[-1], self.empty_positions[change.index]
self.board_[change.position[0], change.position[1]] = 0
def board(self):
return np.copy(self.board_)
def info(self):
return np.array([
self.bets[0] if self.bets[0] is not None else -1,
self.bets[1] if self.bets[1] is not None else -1,
self.chosen_player if self.chosen_player is not None else -1], np.float32)
def group_count(self, id):
result = 0
dys = [-1, 0, 0, 1]
dxs = [0, -1, 1, 0]
visited = np.zeros(self.board_shape, np.bool)
for y in range(self.board_shape[0]):
for x in range(self.board_shape[1]):
if not visited[y][x] and self.board_[y][x] == id:
visited[y][x] = True
result += 1
stack = [(y, x)]
while stack:
p = stack.pop()
for dx, dy in zip(dys, dxs):
dp = (p[0] + dy, p[1] + dx)
if 0 <= dp[0] < self.board_shape[0] and \
0 <= dp[1] < self.board_shape[1] and \
not visited[dp] and self.board_[dp] == id:
visited[dp] = True
stack.append(dp)
return result
def payoff(self):
result = np.array([
self.group_count(1) * self.group_penalty + (self.board_ == 1).sum(),
self.group_count(2) * self.group_penalty + (self.board_ == 2).sum()], np.float32)
if self.bets[0] < self.bets[1]:
result[0] += self.bets[0] + 0.5
elif self.bets[0] > self.bets[1]:
result[1] += self.bets[1] + 0.5
else:
result[self.chosen_player ^ 1] += self.bets[self.chosen_player ^ 1] + 0.5
return result
def summarize_poly_aaa_variants(variants):
columns = [
'snp_id', 'gene', 'poly_aaa_increase', 'poly_aaa_decrease',
'poly_aaa_change', 'chr', 'start', 'end', 'ref', 'alt', 'transcript',
'cds_start', 'cds_end'
]
Record = recordclass('RecordPolyA', columns)
aaa_records = []
aaa_variants = set()
up_variants = {}
down_variants = {}
all_variants_ids = []
variants_sources = Counter()
transcripts = set()
new_poly_a = 0
in_poly_a = 0
for variant in all_poly_a_variants(variants, preserve_sources=True):
all_variants_ids.extend(variant.snp_id.split(','))
new = False
in_a = False
for transcript in variant.affected_transcripts:
if not transcript.poly_aaa:
continue
for alt, aaa_data in transcript.poly_aaa.items():
record = Record(
variant.snp_id,
None, #variant.ensembl_gene_stable_id # TODO
aaa_data.increased,
aaa_data.decreased,
aaa_data.change,
variant.chr_name,
variant.chr_start,
variant.chr_end,
variant.ref,
alt,
transcript.ensembl_id,
transcript.cds_start,
transcript.cds_end)
if not aaa_data.has and aaa_data.will_have:
new = True
if aaa_data.has:
in_a = True
if aaa_data.increased:
up_variants[variant] = True
if aaa_data.decreased:
down_variants[variant] = True
transcripts.add(transcript.ensembl_id)
aaa_records.append(record)
aaa_variants.add(variant)
if new:
new_poly_a += 1
if in_a:
in_poly_a += 1
for source in set(variant.source.split(',')):
variants_sources[source] += 1
report('poly aaa increase and decrease by variants', aaa_records, columns)
report('poly aaa sources', variants_sources.items(), ['source', 'count'])
report('all ids', all_variants_ids)
print('Variants creating new poly(A) tracks: %s' % new_poly_a)
print('Variants in existing poly(A) tracks: %s' % in_poly_a)
print('Affected transcripts: %s' % len(transcripts))
print('Down variants: %s' % len(down_variants))
print('Up variants: %s' % len(up_variants))
print('Unique variants: %s' % len(aaa_variants))
print('Variants identifiers: %s' %
sum(v.snp_id.count(',') + 1 for v in aaa_variants))
print(variants_sources)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import re
from recordclass import recordclass
from math import sqrt
import itertools as it
Part = recordclass('Attrs', 'p v a')
V = recordclass('Vector', 'x y z')
Eq = recordclass('Equation', 'a b c')
parser = re.compile(r'p=<(-?[0-9]+),(-?[0-9]+),(-?[0-9]+)>, '
r'v=<(-?[0-9]+),(-?[0-9]+),(-?[0-9]+)>, '
r'a=<(-?[0-9]+),(-?[0-9]+),(-?[0-9]+)')
def equation(p1, p2, d):
a = .5 * (p1.a[d] - p2.a[d])
return Eq(a, p1.v[d] - p2.v[d] + a, p1.p[d] - p2.p[d])
def md(v):
return sum([abs(v[d]) for d in range(3)])
def collide(p1, p2):
r = []
for d in range(3):
if p1.a[d] == p2.a[d]:
if p1.v[d] == p2.v[d]:
if p1.p[d] != p2.p[d]:
import skimage.morphology
from scipy import ndimage
EPSILON = 0.00000000001
''' These data structures are used in the search function
'''
Circle = collections.namedtuple("Circle", ["radius", "center", "angle", "deflection"])
Path = collections.namedtuple("Path", ["states"])
# wraps a state with additional search information
SearchNode = collections.namedtuple("SearchNode", ["state", "cost", "heuristic", "parent"])
SearchNodeTree = collections.namedtuple("SearchNodeTree", ["state", "cost", "heuristic", "parent", "tree_node"])
# used for recreating the search tree
TreeNode = recordclass.recordclass("TreeNode", ["state", "children"])
class Map(object):
""" Convenience wrapper for an occupancy grid map object.
Provides methods to:
- check distances to nearest objects
- check if points are permissible
- mark map regions as explored
- dilate the map
"""
def __init__(self, map_msg):
self.memoize_disks = True
self.map_msg = map_msg
self.map_info = map_msg.info
# # 0: permissible, -1: unmapped, 100: blocked
self.raw_matrix = np.array(map_msg.data).reshape((map_msg.info.height, map_msg.info.width))
"flip_lr input_height input_width")
ReacherConfig = collections.namedtuple(
"ReacherConfig", "data_dir num_frames im_height im_width batch_size "
"policy channels num_actions max_degree action_coding "
"input_seq_len pred_seq_len n_examples num_joints angles")
BAIRConfig = collections.namedtuple(
"BAIRConfig",
"data_dir num_frames input_res im_height im_width channels batch_size "
"input_seq_len pred_seq_len num_actions n_examples max_seq_length angles rescale_size"
)
TOPConfig = recordclass(
"TOPConfig",
"data_dir num_frames input_res im_height im_width channels batch_size "
"input_seq_len pred_seq_len num_actions n_examples max_seq_length angles "
"flip_lr input_height input_width rescale_size")
GridworldConfig = collections.namedtuple(
"GridworldConfig",
"dataset_type data_file num_frames batch_size image_size "
"input_seq_len pred_seq_len channels max_action num_actions agent_size angles"
)
# A generic config for datasets of (unchunked) videos
VideoDatasetConfig = collections.namedtuple(
"VideoDatasetConfig", "data_dir num_frames "
"im_channels im_height im_width"
"input_seq_len pred_seq_len n_examples")
def test_annotations(self):
C = recordclass('C', [('x',int),('y',int)])
self.assertEqual(C.__new__.__annotations__, {'x':int, 'y':int})
D = recordclass('D', [('x',int),'y'])
self.assertEqual(D.__new__.__annotations__, {'x':int})
def get_peak_coeffs(gain, centre, sr, Q):
A = db2a(gain / 2)
w0 = 2 * pi * centre / sr
cw0 = cos(w0)
sw0 = sin(w0)
alpha = sw0 / 2 * Q
a0 = 1 + alpha / A
b = [(1 + (alpha * A)) / a0, (-2 * cw0) / a0, (1 - alpha * A) / a0]
a = [1, (-2 * cw0) / a0, (1 - alpha / A) / a0]
return b, a
BiquadMemory = recordclass('BiquadMemory', ['z1', 'z2'])
BiquadCoefficients = recordclass(
'BiquadCoefficients', [
'b0', 'b1', 'b2', 'a1', 'a2'])
def biquad_step(i, bm, bc):
out = i * bc.b0 + bm.z1
bm.z1 = i * bc.b1 - bc.a1 * out + bm.z2
bm.z2 = i * bc.b2 - bc.a2 * out
return out
def biquad_cascade(i, bm, bc):
for m, c in zip(bm, bc):
i = biquad_step(i, m, c)
from recordclass import recordclass
from itertools import combinations
import numpy as np
def change_velocity(a1, a2, va1, va2):
if a1 > a2:
return (va1 - 1, va2 + 1)
elif a1 < a2:
return (va1 + 1, va2 - 1)
return va1, va2
Moon = recordclass('Moon', 'n x y z vx vy vz')
f = open("input", "r")
positions = [x.strip('\n').strip('<').strip('>').split(',') for x in f.readlines()]
moons = []
for n, p in enumerate (positions):
x = int(p[0][2:])
y = int(p[1][3:])
z = int(p[2][3:])
moons.append(Moon(n, x, y, z, 0, 0, 0))
for i in range (0, 1000):
pairs = combinations(moons, 2)
for p in pairs:
m1, m2 = p
m1.vx, m2.vx = change_velocity(m1.x, m2.x, m1.vx, m2.vx)
m1.vy, m2.vy = change_velocity(m1.y, m2.y, m1.vy, m2.vy)
m1.vz, m2.vz = change_velocity(m1.z, m2.z, m1.vz, m2.vz)
from recordclass import recordclass
SandboxConfig = recordclass(
"SandboxConfig",
['folder_mappers', 'networking', 'logon_script', 'virtual_gpu'])
def test_factory_doc_attr(self):
Point = recordclass('Point', 'x y')
self.assertEqual(Point.__doc__, 'Point(x, y)')
RawDataExampleDType = [
('id', object),
('dependency_path', object),
('arg1', object),
('arg2', object),
('entity_types', object),
('trigger', object),
('sid', object),
('sentence', object),
('pos', object),
('relation', object),
]
DataExample = recordclass(
"DataExample",
["id", "arg1", "arg2", "feats", "relation", "neg", "trigger"])
DataExampleDType = [('id', int), ('arg1', int, (1, )), ('arg2', int, (1, )),
('feats', list), ('relation', object), ('neg', list),
('trigger', str)]
DataSet = recordclass("DataSet",
["train", "valid", "test"]) # list[DataExample]
AllData = recordclass("AllData", [
'feature_extrs',
'dataset',
'feature_lexicon',
'entity_lexicon',
'relation_lexicon',
])
from recordclass import recordclass
from pyxenoverse.bac.types import BaseType
BACEffectPropertyControl = recordclass('BACEffectPropertyControl', [
'start_time',
'duration',
'u_04',
'character_type',
'skill_id',
'skill_type',
'effect_id',
'effect_duration',
'flags',
'u_12',
'u_14',
'u_16',
])
# Type 27
class EffectPropertyControl(BaseType):
type = 27
bac_record = BACEffectPropertyControl
byte_order = 'HHHHHHHHHHHH'
size = 24
def __init__(self, index):
super().__init__(index)
# | |
# | --- <name>
# | |
# | --- hunk (unit name, content)
# --- bss
# |
# --- <name>
# |
# --- hunk (unit name)
# symbols
# |
# --- <name>
# |
# --- symbol (unit name, hunk type, hunk name, offset)
Hunk = recordclass('Hunk', ('uname', 'content', 'refs', 'relocs'))
Symbol = recordclass('Symbol', ('uname', 'htype', 'hname', 'offset'))
Reloc = recordclass('Reloc', ('uname', 'htype', 'hname', 'hnum', 'offset'))
Reference = recordclass('Reference', ('sname', 'type', 'offset'))
DataBase = recordclass('DataBase', ('hunks', 'symbols', 'map'))
db = DataBase(hunks = {'code': {}, 'data': {}, 'bss': {}}, symbols = {}, map = {})
# block types from from dos/doshunks.h
class BlockType(IntEnum):
HUNK_UNIT = 999
HUNK_NAME = 1000
HUNK_CODE = 1001
HUNK_DATA = 1002
"""
A template for the baseline methods that participate in the evaluation of
eval2.py.
"""
from abc import ABCMeta, abstractmethod
import random
from recordclass import recordclass
import re
SuggestItem = recordclass('SuggestItem', ['elem', 'score'])
class Context:
"""
Vehicle of all the necessary information to be included in a query for the
model to make a prediction.
This abstract representation is composed only of functions called, parameter
used, return relations, etc.
There are a corresponding preprocessor and postprocessor (e.g., matching
model's suggested highlight with user's cursor position, etc.)
This class itself should not contain any thing about the messy world.
"""
def __init__(self, used_elem_ids, used_elem_objs=None, var_map=None):
"""
SIMPLIFIED elements (string IDs) only.
from __future__ import print_function, division import os, sys from recordclass import recordclass # 'extra' is for extra lines OBJ = recordclass( 'OBJ', ['v','vt','vn','f','extra','filename'] ) FaceVertex = recordclass( 'FaceVertex', ['v','vt','vn'] ) def load_obj( filename ): print( "Loading:", filename ) with open( filename ) as lines: v = [] vt = [] vn = [] f = [] extra_lines = [] for line in lines: sline = line.strip().split() if len( sline ) == 0: continue if sline[0] == 'v': v.append( tuple( map( float, sline[1:] ) ) ) elif sline[0] == 'vt': vt.append( tuple( map( float, sline[1:] ) ) ) elif sline[0] == 'vn': vn.append( tuple( map( float, sline[1:] ) ) ) elif sline[0] == 'f': ## Pad bundle with two extra '//' and then take the first three values in between.
def __init__(self):
self.expected_set_cache = {}
self.queries = []
# load the ground-truth file
with open('eval-gt-2.csv', 'rb') as csv_file:
reader = csv.reader(csv_file)
# columns:
# case_study_no,answer_func,answer_arg,query
Query = recordclass('Query', next(reader))
for query in imap(Query._make, reader):
assert query.case_study_no.startswith('example-')
query.case_study_no = int(query.case_study_no.replace('example-', ''))
query.answer = query.answer.strip()
query.query = query.query.strip()
query.query_source = query.query_source.strip()
self.queries.append(query)
print 'Loading the code samples...'
self.code_samples = []
fnames = [relative_path('demo/code-samples/before_afters/before%d.py'%x)
for x in [1,2,3,4,5]]
for f in fnames:
with open(f) as reader:
code = reader.read().strip()
self.code_samples.append(code)
print 'Initializing context builder...'
self.cb = ContextBuilder()
print 'Initializing element normalizer...'
self.enormer = ElementNormalizer()
print 'Instantiating baselines...'
self.baselines = []
self.baselines.append(RandomBaseline(self.cb.getAllElements()))
w2vb1 = Word2vecBaseline(
relative_path('models/output/vectors-so-text-python-lemma.bin'),
self.cb.getAllElementCounts(), 1, 'w2v')
w2vb2 = Word2vecBaseline(w2vb1.model,
self.cb.getAllElementCounts(), 1, 'w2v-heuristic', heuristic=True)
w2vb3 = Word2vecBaseline(w2vb1.model,
self.cb.getAllElementCounts(), 1, 'w2v-cooccur', use_coke=True)
w2vb4 = Word2vecBaseline(w2vb1.model,
self.cb.getAllElementCounts(), 1, 'w2v-hc', heuristic=True, use_coke=True)
self.baselines += [w2vb1, w2vb2, w2vb3, w2vb4]
# bimodal = BiModalBaseline('bimodal-concat-10epoch',
# relative_path('models/output/bi2-test-ggg.model'),
# relative_path('models/output/vectors-flat-mpl-0205.bin'))
# bimodal_ids = list('denopq')
bimodal_ids = list('d')
for id_ in bimodal_ids:
bimodal = BiModalBaseline('bimodal-'+id_,
relative_path('models/output/bi2-0410-%s.model'%id_),
w2vb1.model)
self.baselines.append(bimodal)
print 'Starts evaluating...'
metric_names = ['MRR', 'P@1', 'P@5', 'P@10']
results = np.zeros((len(self.baselines), len(metric_names)), dtype=float)
result_log = [] # for diagnosis
count_query = 0
for idx, code in enumerate(self.code_samples):
# triple-for-loop structure: {code-sample -> gt -> baseline}.
print 'Processing code sample %d'%(idx + 1)
current_queries = filter(lambda x: int(x.case_study_no) == int(idx + 1), self.queries)
assert current_queries
context = self.cb.getContext(code)
for query in current_queries: # "query" = "ground truth"
count_query += 1
assert query.answer
for b_idx, b in enumerate(self.baselines):
suggested_items = b.suggest(query.query, context)
answer_rank = self.getRankOfExpectedItem(
suggested_items, code, query.answer)
mrr_idx = metric_names.index('MRR')
p1_idx = metric_names.index('P@1')
p5_idx = metric_names.index('P@5')
p10_idx = metric_names.index('P@10')
if answer_rank > 0:
results[b_idx, mrr_idx] += 1. / answer_rank
if answer_rank == 1:
results[b_idx, p1_idx] += 1
if answer_rank <= 5:
results[b_idx, p5_idx] += 1
if answer_rank <= 10:
results[b_idx, p10_idx] += 1
self.updateResultLog(result_log, idx + 1, query.query, b,
suggested_items, code, query.answer,
answer_rank)
assert count_query > 0
for metric_idx, metric in enumerate(metric_names):
if metric == 'MRR' or metric.startswith('P@'):
results[:, metric_idx] /= count_query
# output
print 'Writing outputs...'
with open(relative_path('models/output/eval-result-0413.csv'), 'wb') as csv_file:
writer = csv.writer(csv_file)
writer.writerow(['Baseline'] + metric_names)
for b_idx, b in enumerate(self.baselines):
writer.writerow([b.__repr__()] + results[b_idx].tolist())
with open(relative_path('models/output/eval-log-0413.csv'), 'wb') as csv_file:
writer = csv.writer(csv_file)
writer.writerow(ResultLogEntry._fields)
for row in result_log:
writer.writerow(row)
# close resources
print 'Closing resources'
# whoosh_baseline.close()
print 'Done'
from __future__ import print_function, division
import os, sys
from recordclass import recordclass
# 'extra' is for extra lines
OBJ = recordclass("OBJ", ["v", "vt", "vn", "f", "extra", "filename"])
FaceVertex = recordclass("FaceVertex", ["v", "vt", "vn"])
def load_obj(filename):
print("Loading:", filename)
with open(filename) as lines:
v = []
vt = []
vn = []
f = []
extra_lines = []
for line in lines:
sline = line.strip().split()
if len(sline) == 0:
continue
if sline[0] == "v":
v.append(tuple(map(float, sline[1:])))
elif sline[0] == "vt":
vt.append(tuple(map(float, sline[1:])))
elif sline[0] == "vn":
vn.append(tuple(map(float, sline[1:])))
MapStruct = collections.namedtuple('MapStruct', 'cells height width depth')
def load_map(map_path):
map_data = open(map_path, 'rb').read()
eb = (len(map_data) - 3) % 4
if eb > 0:
#print("{}: {} extra bytes".format(map_path, eb))
# many maps seem to have an extra byte tacked on.
# must be a bug in some editor
pass
return MapStruct(
[MapRec(*rec) for rec in struct.iter_unpack('4B', map_data[3:-eb])],
*struct.unpack('3B', map_data[:3]))
MCDRec = recordclass('MCDRec', '''origin Frame LOFT ScanG UFO_Door
Stop_LOS No_Floor Big_Wall Gravlift Door Block_Fire Block_Smoke
u39 TU_Walk TU_Slide TU_Fly Armor HE_Block Die_MCD Flammable Alt_MCD
u48 T_Level P_Level u51 Light_Block Footstep Tile_Type HE_Type
HE_Strength Smoke_Blockage Fuel Light_Source Target_Type Xcom_Base u62''')
MCDStruct = struct.Struct("<8s12sH8x12B6Bb13B")
MCDPatchMap = {
'bigWall': 'Big_Wall',
'TUWalk': 'TU_Walk',
'TUSlide': 'TU_Slide',
'TUFly': 'TU_Fly',
'deathTile': 'Die_MCD',
'terrainHeight': 'T_Level',
'specialType': 'Target_Type',
'explosive': 'HE_Strength',
'armor': 'Armor',
'flammability': 'Flammable',
elem_counts = bh.load('elem_pyplot_counts_0404')
enormer = ElementNormalizer()
rtype_lookup = {} # [elem_id] = rtype (simplified)
with open(relative_path(
'docstring_parse/annotation/rtype_map.csv'), 'rb') as csvfile:
reader = csv.reader(csvfile)
for elem_id, rtype in reader:
rtype_lookup[elem_id] = enormer.unsimplify(rtype)
adoc_lookup = {} # [elem_id] = utter (additional doc)
with open(relative_path(
'docstring_parse/annotation/additional_doc.csv'), 'rb') as csvfile:
reader = csv.reader(csvfile)
ADoc = recordclass('ADoc', next(reader))
assert ADoc._fields == ('elem_id', 'doc')
for adoc in imap(ADoc._make, reader):
adoc_lookup[adoc.elem_id] = adoc.doc
aref_lookup = defaultdict(set) # [elem_id] = [ARef] (additional reference)
with open(relative_path(
'docstring_parse/annotation/additional_ref.csv'), 'rb') as csvfile:
reader = csv.reader(csvfile)
ARef = namedtuple('ARef', next(reader))
assert ARef._fields == ('elem_id', 'ref', 'type')
for aref in imap(ARef._make, reader):
aref_lookup[aref.elem_id].add(aref)
# Use aref to augment fau and create faku
faku = {} # [f@a,k] = utter
import os
from pprint import pprint
from recordclass import recordclass
from gpt3.bleu.util import read_file, json_create, json_append_dict, query
File = recordclass("File", "file language")
Test = recordclass("Test", "src target")
def openai_prompt(test, src_examples, tar_examples, src_line):
if len(src_examples) == 0:
return f"Q: What is the {test.target.language} translation of {src_line}\nA:"
else:
few_shots = "\n\n".join([
f"{src}\t=\t{tar}" for src, tar in zip(src_examples, tar_examples)
])
return f"Translate {test.src.language} to {test.target.language}:\n{few_shots}\n\n{src_line}\t="
def openai_quote_prompt(test, src_examples, tar_examples, src_line):
if len(src_examples) == 0:
return f"Q: What is the {test.target.language} translation of \"{src_line}\"\nA: \""
else:
p = lambda src, tar: f"\"{src}\" = \"{tar}\""
few_shots = "\n\n".join(
[p(src, tar) for src, tar in zip(src_examples, tar_examples)])
return (f"Translate {test.src.language} to {test.target.language}:"
f"\n{few_shots}"
f"\n\n\"{src_line}\" = \"")
# quote_symb = '"' if '"' not in src_line else "'"
# if quote_symb in src_line:
import struct
from recordclass import recordclass
from pyxenoverse import BaseRecord
EANKeyframe = recordclass('EANKeyframe', ['x', 'y', 'z', 'w'])
class Keyframe(BaseRecord):
def __init__(self, frame=0, w=0, x=0, y=0, z=0):
self.frame = frame
super().__init__()
self.data = EANKeyframe(x, y, z, w)
def __lt__(self, other):
return self.frame < other.frame
def paste(self, other):
self.data = EANKeyframe(*other.data)
def read(self, f, keyframe_size, endian):
if keyframe_size == 1:
self.data = EANKeyframe(*struct.unpack(endian + 'eeee', f.read(8)))
else:
self.data = EANKeyframe(*struct.unpack(endian +
'ffff', f.read(16)))
# print(" (keyframe_size:{}) X : {}, Y : {}, Z : {}, W : {}".format(
# keyframe_size, self.x, self.y, self.z, self.w))
def write(self, f, keyframe_size, endian):
if keyframe_size == 1:
from recordclass import recordclass
"""
- utter: for machine to read; i.e., for model to consume
- utter_expand: for human to interpret.
# Note: these doc records can be additionally indexed by parent_id, and thus
# children can be easily found.
"""
ElemDoc = recordclass('ElemDoc', ('elem_id', 'name',
'full_name', 'type',
'parent_id', 'rtype', 'count',
'utter', 'utter_expand'))
# Snarkback game bot
# Matthew Kroesche
import discord
import recordclass
import random
import os
import datetime
import asyncio
import urllib.request
from .game import Game
Player = recordclass.recordclass('Player', 'user score round_score prompts snarks votes num_votes')
# user: the discord.User controlling this player
# score: the score of this player at the end of the last round
# round_score: the number of points accumulated by this player in the current round
# prompts: the list of string prompts given to this player
# snarks: the list of string responses by this player to the prompts
# votes: the list of integer indices representing votes cast by this player
# num_votes: the number of votes this player needs to cast
MAX_SNARK_SIZE = 50 # The maximum length of a reply to a prompt
# Timer settings
PROMPT_TIMER = 90 # The timer for a prompt
FINAL_PROMPT_TIMER = 45 # The timer for a prompt in round three
