docstr: Test historical restrictions for both interday and intraday
  restrictions, as well as restrictions defined in/not in order, for both
  single- and multi-asset queries
docstr_tok: ["Test","historical","restrictions","for","both","interday","and","intraday","restrictions",",","as","well","as","restrictions","defined","in\/not","in","order",",","for","both","single-","and","multi-asset","queries"]
code: def test_historical_restrictions(
      self, date_offset, restriction_order
  ):
      """
      Test historical restrictions for both interday and intraday
      restrictions, as well as restrictions defined in/not in order, for both
      single- and multi-asset queries
      """
  
      def rdate(s):
          """Convert a date string into a restriction for that date."""
          # Add date_offset to check that we handle intraday changes.
          return str_to_ts(s) + date_offset
  
      base_restrictions = [
          Restriction(self.ASSET1, rdate("2011-01-04"), FROZEN),
          Restriction(self.ASSET1, rdate("2011-01-05"), ALLOWED),
          Restriction(self.ASSET1, rdate("2011-01-06"), FROZEN),
          Restriction(self.ASSET2, rdate("2011-01-05"), FROZEN),
          Restriction(self.ASSET2, rdate("2011-01-06"), ALLOWED),
          Restriction(self.ASSET2, rdate("2011-01-07"), FROZEN),
      ]
      # Scramble the restrictions based on restriction_order to check that we
      # don't depend on the order in which restrictions are provided to us.
      all_restrictions = [
          base_restrictions[i] for i in restriction_order
      ]
  
      restrictions_by_asset = groupby(
          lambda r: r.asset, all_restrictions
      )
  
      rl = HistoricalRestrictions(all_restrictions)
      assert_not_restricted = partial(self.assert_not_restricted, rl)
      assert_is_restricted = partial(self.assert_is_restricted, rl)
      assert_all_restrictions = partial(
          self.assert_all_restrictions, rl
      )
  
      # Check individual restrictions.
      for asset, r_history in iteritems(restrictions_by_asset):
          freeze_dt, unfreeze_dt, re_freeze_dt = sorted(
              [r.effective_date for r in r_history]
          )
  
          # Starts implicitly unrestricted. Restricted on or after the freeze
          assert_not_restricted(asset, freeze_dt - MINUTE)
          assert_is_restricted(asset, freeze_dt)
          assert_is_restricted(asset, freeze_dt + MINUTE)
  
          # Unrestricted on or after the unfreeze
          assert_is_restricted(asset, unfreeze_dt - MINUTE)
          assert_not_restricted(asset, unfreeze_dt)
          assert_not_restricted(asset, unfreeze_dt + MINUTE)
  
          # Restricted again on or after the freeze
          assert_not_restricted(asset, re_freeze_dt - MINUTE)
          assert_is_restricted(asset, re_freeze_dt)
          assert_is_restricted(asset, re_freeze_dt + MINUTE)
  
          # Should stay restricted for the rest of time
          assert_is_restricted(asset, re_freeze_dt + MINUTE * 1000000)
  
      # Check vectorized restrictions.
      # Expected results for [self.ASSET1, self.ASSET2, self.ASSET3],
      # ASSET3 is always False as it has no defined restrictions
  
      # 01/04 XX:00 ASSET1: ALLOWED --> FROZEN; ASSET2: ALLOWED
      d0 = rdate("2011-01-04")
      assert_all_restrictions([False, False, False], d0 - MINUTE)
      assert_all_restrictions([True, False, False], d0)
      assert_all_restrictions([True, False, False], d0 + MINUTE)
  
      # 01/05 XX:00 ASSET1: FROZEN --> ALLOWED; ASSET2: ALLOWED --> FROZEN
      d1 = rdate("2011-01-05")
      assert_all_restrictions([True, False, False], d1 - MINUTE)
      assert_all_restrictions([False, True, False], d1)
      assert_all_restrictions([False, True, False], d1 + MINUTE)
  
      # 01/06 XX:00 ASSET1: ALLOWED --> FROZEN; ASSET2: FROZEN --> ALLOWED
      d2 = rdate("2011-01-06")
      assert_all_restrictions([False, True, False], d2 - MINUTE)
      assert_all_restrictions([True, False, False], d2)
      assert_all_restrictions([True, False, False], d2 + MINUTE)
  
      # 01/07 XX:00 ASSET1: FROZEN; ASSET2: ALLOWED --> FROZEN
      d3 = rdate("2011-01-07")
      assert_all_restrictions([True, False, False], d3 - MINUTE)
      assert_all_restrictions([True, True, False], d3)
      assert_all_restrictions([True, True, False], d3 + MINUTE)
  
      # Should stay restricted for the rest of time
      assert_all_restrictions(
          [True, True, False], d3 + (MINUTE * 10000000)
      )
  
imports: import pandas
  from pandas.util.testing import assert_series_equal
  from six import iteritems
  from functools import partial
  from toolz import groupby
  from zipline.finance.asset_restrictions import RESTRICTION_STATES, Restriction, HistoricalRestrictions, StaticRestrictions, SecurityListRestrictions, NoRestrictions, _UnionRestrictions
  from zipline.testing import parameter_space
  from zipline.testing.fixtures import WithDataPortal, ZiplineTestCase
label_desc: Use image node_id 6 for calling the RestrictionsTestCase obj's underlying member method code with example usage: obj.test_historical_restrictions(date_offset, restriction_order) and returns: unknown