wassname/catalyst
1
0
Fork 0
mirror of https://github.com/wassname/catalyst.git synced 2026-07-02 12:29:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

MAINT: Remove ndict class.

Browse Source 
Now that ndict is no longer used in any part of the system during
a backtest, remove all remaining references in tests, etc.
This commit is contained in:
Eddie Hebert
2013-04-26 16:03:01 -04:00
parent 89ea97ec52
commit b3efb5eb69
9 changed files with 7 additions and 272 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_ndict.py
-107
View File
@@ -1,107 +0,0 @@
#
# Copyright 2012 Quantopian, 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.
from datetime import datetime
import pytz
from copy import deepcopy
from zipline.utils.protocol_utils import ndict
def test_ndict():
nd = ndict({})
# Properties
assert len(nd) == 0
assert nd.keys() == []
assert nd.values() == []
assert list(nd.iteritems()) == []
# Accessors
nd['x'] = 1
assert nd.x == 1
assert nd['x'] == 1
assert nd.get('y') is None
assert nd.get('y', 'fizzpop') == 'fizzpop'
assert 'x' in nd
assert 'y' not in nd
assert 'x' in nd
assert 'y' not in nd
# Mutability
nd2 = ndict({'x': 1})
assert nd2.x == 1
nd2.x = 2
assert nd2.x == 2
# Class isolation
assert '__init__' not in nd
assert '__iter__' not in nd
assert 'x' not in nd.__dict__
assert nd.get('__init__') is None
assert 'x' not in set(dir(nd))
# Comparison
nd2 = nd.copy()
assert id(nd2) != id(nd)
assert nd2 == nd
nd2['z'] = 3
assert nd2 != nd
class ndictlike(object):
x = 1
assert {'x': 1} == nd
assert ndictlike() != nd
# Deletion
del nd['x']
assert 'x' not in nd
assert nd.get('x') is None
for n in xrange(1000):
dt = datetime.utcnow().replace(tzinfo=pytz.utc)
nd2 = ndict({"dt": dt,
"otherdata": "ishere" * 1000,
"maybeanint": 3})
nd2.dt2 = dt
def test_ndict_deepcopy():
def assert_correctly_copied(orig, copy):
assert nd == nd_dc, \
"Deepcopied ndict should have same keys and values."
nd_dc.z = 3
assert 'z' not in nd, "'z' also added to original ndict."
nd_dc.y = 10
assert nd_dc.y == 10, "value of copied ndict not correctly set."
assert nd.y != 10, "value also set of original ndict."
nd = ndict({'x': 1, 'y': 2})
nd_dc = deepcopy(nd)
assert_correctly_copied(nd, nd_dc)
nd = ndict({'x': [1, 2, 3],
'y': {1: 1}})
nd_dc = deepcopy(nd)
assert_correctly_copied(nd, nd_dc)
nd_dc.x.append(4)
assert nd_dc.x[-1] == 4, "not correctly appended to copied."
assert nd.x[-1] != 4, "also copied to original."
tests/test_transforms.py
+2 -3
View File
@@ -22,10 +22,9 @@ import pandas as pd
from datetime import timedelta, datetime
from unittest import TestCase
from zipline import ndict
from zipline.utils.test_utils import setup_logger
from zipline.protocol import Event
from zipline.sources import SpecificEquityTrades
from zipline.transforms.utils import StatefulTransform, EventWindow
from zipline.transforms import MovingVWAP
@@ -38,7 +37,7 @@ from zipline.test_algorithms import BatchTransformAlgorithm
def to_dt(msg):
return ndict({'dt': msg})
return Event({'dt': msg})
class NoopEventWindow(EventWindow):
zipline/__init__.py
-2
View File
@@ -5,7 +5,6 @@ Zipline
# This is *not* a place to dump arbitrary classes/modules for convenience,
# it is a place to expose the public interfaces.
from zipline.utils.protocol_utils import ndict
import data
import finance
@@ -15,7 +14,6 @@ import utils
from algorithm import TradingAlgorithm
__all__ = [
'ndict',
'data',
'finance',
'gens',
zipline/gens/utils.py
-6
View File
@@ -73,9 +73,3 @@ def assert_sort_unframe_protocol(event):
"""Same as above."""
assert isinstance(event.source_id, basestring)
assert event.type in DATASOURCE_TYPE
def assert_merge_protocol(tnfm_ids, message):
"""Merge should output an ndict with a field for each id
in its transform set."""
assert set(tnfm_ids) == set(message.keys())
zipline/test_algorithms.py
+2 -2
View File
@@ -32,8 +32,8 @@ The algorithm must expose methods:
sids. List must have a length between 1 and 10. If None is returned the
filter will block all events.
- handle_data: method that accepts a :py:class:`zipline.protocol_utils.ndict`
of the current state of the simulation universe. An example data ndict:
- handle_data: method that accepts a :py:class:`zipline.protocol.BarData`
of the current state of the simulation universe. An example data object:
.. This outputs the table as an HTML table but for some reason there
is no bounding box. Make the previous paragraph ending colon a
zipline/transforms/mavg.py
+2 -2
View File
@@ -67,7 +67,7 @@ class MovingAverage(object):
def update(self, event):
"""
Update the event window for this event's sid. Return an ndict
Update the event window for this event's sid. Return a dict
from tracked fields to moving averages.
"""
# This will create a new EventWindow if this is the first
@@ -141,7 +141,7 @@ class MovingAverageEventWindow(EventWindow):
def get_averages(self):
"""
Return an ndict of all our tracked averages.
Return a dict of all our tracked averages.
"""
out = Averages()
for field in self.fields:
zipline/transforms/stddev.py
+1 -1
View File
@@ -63,7 +63,7 @@ class MovingStandardDev(object):
def update(self, event):
"""
Update the event window for this event's sid. Return an ndict
Update the event window for this event's sid. Return a dict
from tracked fields to moving averages.
"""
# This will create a new EventWindow if this is the first
zipline/utils/__init__.py
-4
View File
@@ -1,4 +0,0 @@
from protocol_utils import ndict
__all__ = [
ndict,
]
zipline/utils/protocol_utils.py
-145
View File
@@ -13,11 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import pandas
from ctypes import Structure, c_ubyte
from collections import MutableMapping
def Enum(*options):
@@ -30,144 +26,3 @@ def Enum(*options):
_fields_ = [(o, c_ubyte) for o in options]
__iter__ = lambda s: iter(range(len(options)))
return cstruct(*range(len(options)))
class ndict(MutableMapping):
"""
Xtreme Namedicts 2.0
Ndicts are dict like objects that have fields accessible by attribute
lookup as well as being indexable and iterable. Done right
this time.
"""
cls = None
__slots__ = ['cls', '__internal']
def __init__(self, dct=None, internal=None):
if internal is not None:
self.__internal = internal
else:
self.__internal = dict()
if not ndict.cls:
ndict.cls = frozenset(dir(self))
if dct:
self.__internal.update(dct)
# Abstact Overloads
# -----------------
def __deepcopy__(self, memo):
return ndict(copy.deepcopy(self.__internal))
def __setattr__(self, key, value):
if key == 'cls' or key == '__internal' or '_ndict' in key:
super(ndict, self).__setattr__(key, value)
else:
self.__internal[key] = value
return value
def __setitem__(self, key, value):
"""
Required for use by pymongo as_class parameter to find.
"""
if key == '_id':
self.__internal['id'] = value
else:
self.__internal[key] = value
def __getattr__(self, key):
if key in self.cls:
super(ndict, self).__getattr__(key)
else:
return self.__internal[key]
def __getitem__(self, key):
return self.__internal[key]
def __delitem__(self, key):
del self.__internal[key]
def __iter__(self):
return self.__internal.iterkeys()
def __len__(self):
return len(self.__internal)
#TODO: Eddie please help!
def __contains__(self, key):
if hasattr(self, '_ndict_contains__'):
return self._ndict_contains__(key)
else:
return self.__internal.__contains__(key)
# Compatability with namedicts
# ----------------------------
# for compat, not the Python way to do things though...
# Deprecated, use builtin ``del`` operator.
delete = __delitem__
def has_attr(self, key):
"""
Deprecated, use builtin ``in`` operator.
"""
return self.__contains__(key)
def has_key(self, key):
return self.__contains__(key)
# Custom Methods
# --------------
def copy(self):
return ndict(copy.copy(self.__internal))
def as_dataframe(self):
"""
Return the representation as a Pandas dataframe.
"""
d = pandas.DataFrame(self.__internal)
return d
def as_series(self):
"""
Return the representation as a Pandas time series.
"""
s = pandas.Series(self.__internal)
s.name = self.sid
return s
def as_dict(self):
"""
Return the representation as a vanilla Python dict.
"""
# shallow copy is O(n)
return copy.copy(self.__internal)
def merge(self, other_nd):
"""
Merge in place with another ndict.
"""
assert isinstance(other_nd, ndict)
self.__internal.update(other_nd.__internal)
def __repr__(self):
return "ndict(%s)" % str(self.__internal)
# Faster dictionary comparison?
#def __eq__(self, other):
#assert isinstance(other, ndict)
#keyeq = set(self.keys()) == set(other.keys())
#if not keyeq:
#return False
#for i, j in izip(self.itervalues(), other.itervalues()):
#if i != j:
#return False
#return True