def __init__(self, bid_name, artificial=None, opening=None, transfer_to=None, takeout_double=None, negative_double=None, penalty_double=None, lead_directing_double=None, blackwood=None, gerber=None, michaels_cuebid=None, michaels_minor_request=None, unusual_two_nt=None, stayman=None, jacoby_two_nt=None, jacoby_transfer=None, two_spades_puppet=None, fourth_suit_forcing=None, preempt=None, jordan=None, two_nt_feature_request=None): Call.__init__(self, bid_name) self.artificial = artificial or False self.preempt = preempt or False self.opening = opening or False self.transfer_to = transfer_to self.takeout_double = takeout_double or False self.negative_double = negative_double or False self.penalty_double = penalty_double or False self.lead_directing_double = lead_directing_double or False self.blackwood = blackwood or False self.gerber = gerber or False # FIXME: Stayman could be written more generically on HandConstraints by promising a 4-card major. self.stayman = stayman or False # FIXME: Michaels could be written more generically on HandConstraints by promising a 5-card minor. self.michaels_cuebid = michaels_cuebid or False self.michaels_minor_request = michaels_minor_request or False # FIXME: Unusual2NT could be written more generically on HandConstraints by promising a 5-card major. self.unusual_two_nt = unusual_two_nt or False self.jacoby_two_nt = jacoby_two_nt or False self.jacoby_transfer = jacoby_transfer or False # FIXME: TwoSpadesPuppet could be written more generically on HandConstraints by promising a 6-card minor. self.two_spades_puppet = two_spades_puppet or False self.fourth_suit_forcing = fourth_suit_forcing or False self.two_nt_feature_request = two_nt_feature_request or False self.jordan = jordan or False # Jordan doesn't really need its own flag, no one ever checks it.
def from_expectation_tuple_in_group(cls, expectation, test_group): hand_string = expectation[0] assert '.' in hand_string, "_split_expectation expectes C.D.H.S formatted hands, missing '.': %s" % hand_string expected_call = Call.from_string(expectation[1]) history_string = expectation[2] if len(expectation) > 2 else "" vulnerability_string = expectation[3] if len(expectation) > 3 else None hand = Hand.from_cdhs_string(hand_string) call_history = CallHistory.from_string(history_string, vulnerability_string=vulnerability_string) return cls(test_group, hand, call_history, expected_call)
def call(cls, callstring, who): bidder = cls.position(who) if pattern_pass.match(callstring): return CallWithStateInfo(Pass(), bidder) elif pattern_rdbl.match(callstring): return CallWithStateInfo(Rdbl(), bidder) elif pattern_dbl.match(callstring): return CallWithStateInfo(Dbl(), bidder) else: return CallWithStateInfo(Call(callstring.upper()), bidder)
def possible_calls_over(self, history): if history.is_complete(): return yield Call('P') last_non_pass = history.last_non_pass() caller = history.position_to_call() if last_non_pass and history.last_to_not_pass() != caller.partner: if last_non_pass.is_contract(): yield Call('X') elif last_non_pass.is_double(): yield Call('XX') last_contract = history.last_contract() for level in range(1, 8): if last_contract and level < last_contract.level: continue for strain in STRAINS: if last_contract and level == last_contract.level and strain <= last_contract.strain: continue yield Call.from_level_and_strain(level, strain)
def test_names(self): self.assertEqual(list(Call.suited_names_between('1C', '1H')), ['1C', '1D', '1H']) self.assertEqual(list(Call.suited_names_between('2D', '4H')), ['2D', '2H', '2S', '3C', '3D', '3H', '3S', '4C', '4D', '4H']) self.assertEqual(list(Call.notrump_names_between('1N', '7N')), ['1N', '2N', '3N', '4N', '5N', '6N', '7N']) self.assertEqual(list(Call.notrump_names_between('3N', '5N')), ['3N', '4N', '5N'])
def _glob_helper(self, history, call_name): call = Call.from_string(call_name) # call_name can be empty if the original string is emtpy or there is trailing whitespace. if call and history.is_legal_call(call): yield call
def _assert_is_legal_call(self, history_string, bid, is_legal=True): call_history = CallHistory.from_string(history_string) bid = Call.from_string(bid) self.assertEquals(call_history.is_legal_call(bid), is_legal)
def _assert_is_legal_call(self, history_string, call_name, is_legal=True): call_history = CallHistory.from_string(history_string) call = Call.from_string(call_name) self.assertEquals(call_history.is_legal_call(call), is_legal)
# found in the LICENSE file. from core import suit from z3b import enum from z3b.constraints import * from z3b.model import * from z3b.preconditions import * from z3b.rule_compiler import Rule, rule_order, categories from core.call import Call def copy_dict(d, keys): return {key: d.get(key) for key in keys} natural = enum.Enum(*Call.suited_names()) notrump_without_stoppers = enum.Enum(*Call.notrump_names()) notrump_with_stoppers = enum.Enum(*Call.notrump_names()) natural_slams = rule_order.order( notrump_without_stoppers.get('6N'), natural.get('6C'), natural.get('6D'), natural.get('6H'), natural.get('6S'), notrump_with_stoppers.get('6N'), notrump_without_stoppers.get('7N'),