def testSimplePreds(self):
[dispatch.generic()]
def classify(age):
"""Stereotype for age"""
def defmethod(gf,s,func):
gf.addMethod(gf.parse(s,locals(),globals()),func)
defmethod(classify,'not not age<2', lambda age:"infant")
defmethod(classify,'age<13', lambda age:"preteen")
defmethod(classify,'age<5', lambda age:"preschooler")
defmethod(classify,'20>age', lambda age:"teenager")
defmethod(classify,'not age<20',lambda age:"adult")
defmethod(classify,'age>=55',lambda age:"senior")
defmethod(classify,'age==16',lambda age:"sweet sixteen")
self.assertEqual(classify(25),"adult")
self.assertEqual(classify(17),"teenager")
self.assertEqual(classify(13),"teenager")
self.assertEqual(classify(12.99),"preteen")
self.assertEqual(classify(0),"infant")
self.assertEqual(classify(4),"preschooler")
self.assertEqual(classify(55),"senior")
self.assertEqual(classify(54.9),"adult")
self.assertEqual(classify(14.5),"teenager")
self.assertEqual(classify(16),"sweet sixteen")
self.assertEqual(classify(16.5),"teenager")
self.assertEqual(classify(99),"senior")
self.assertEqual(classify(Min),"infant")
self.assertEqual(classify(Max),"senior")
def test_NoApplicableMethods_is_raised(self):
[dispatch.generic()]
def demo_func(number):
pass
demo_func.when("number < 10")(lambda x: 0)
self.assertEqual(demo_func(3),0)
self.assertRaises(dispatch.NoApplicableMethods, demo_func, 33)
def test_NoApplicableMethods_is_raised(self):
[dispatch.generic()]
def demo_func(number):
pass
demo_func.when("number < 10")(lambda x: 0)
self.assertEqual(demo_func(3), 0)
self.assertRaises(dispatch.NoApplicableMethods, demo_func, 33)
def testKwArgHandling(self):
[dispatch.generic()]
def f(**fiz): """Test of kw handling"""
[f.when("'x' in fiz")]
def f(**fiz): return "x"
[f.when("'y' in fiz")]
def f(**fiz): return "y"
self.assertEqual(f(x=1),"x")
self.assertEqual(f(y=1),"y")
self.assertRaises(AmbiguousMethod, f, x=1, y=1)
def testSubclassDispatch(self):
[dispatch.generic()]
def gm (t) : pass
[gm.when(default)]
def gm (t) : return 'default'
[gm.when('issubclass(t,int)')]
def gm2 (t) : return 'int'
self.assertEqual(gm(int),"int")
self.assertEqual(gm(object),"default")
self.assertEqual(gm(float),"default")
def testVarArgHandling(self):
[dispatch.generic()]
def f(*fiz): """Test of vararg handling"""
[f.when("'x' in fiz")]
def f(*fiz): return "x"
[f.when("'y' in fiz")]
def f(*fiz): return "y"
self.assertEqual(f("foo","x"),"x")
self.assertEqual(f("bar","q","y"),"y")
self.assertEqual(f("bar","q","y"),"y")
self.assertEqual(f("y","q",),"y")
self.assertRaises(AmbiguousMethod, f, "x","y")
class X:
[dispatch.generic()]
def s(self, v):
"""X"""
[s.when("v in LandVehicle")]
def bar(self, v):
return "land"
[s.when("v in WaterVehicle")]
def s(self, v):
return "water"
def initBeforeAfter(self): #{{{
run_signal = Signal(base_signal)
run_signal.connect_before(dict(before=[base_before]))
run_signal.connect_after(dict(after=[base_after]))
run_deco = decosig(overload=False)(base_signal)
run_deco.before(base_before)
run_deco.after(base_after)
run_rule = dispatch.generic()(lambda l: l)
run_rule.when('True')(base_signal)
run_rule.before('True')(base_before)
run_rule.after('True')(base_after)
louie.connect(base_before, 'before_after', base_signal)
louie.connect(base_signal, 'before_after', base_signal)
louie.connect(base_after, 'before_after', base_signal)
def run_louie(l): #{{{
ret = louie.send('before_after', base_signal, l)
return ret[1][1]
# End def #}}}
run_aossi_basesignal = BaseSignal(base_signal)
run_aossi_basesignal.connect(before=[base_before])
run_aossi_basesignal.connect(after=[base_after])
run_aossi_signal = AossiSignal(base_signal)
run_aossi_signal.connect(before=[base_before])
run_aossi_signal.connect(after=[base_after])
run_aossi_deco = aossi_signal()(base_signal)
run_aossi_deco.before(base_before)
run_aossi_deco.after(base_after)
ba = {'base': run_base,
'signal': run_signal,
'deco': run_deco,
'rule': run_rule,
'louie': run_louie,
'aossi_basesignal': run_aossi_basesignal,
'aossi_signal': run_aossi_signal,
'aossi_deco': run_aossi_deco}
dpath = op.join('data', 'before_after')
if not op.exists(dpath):
os.makedirs(dpath, 0700)
return ba
def testSubclassDispatch(self):
[dispatch.generic()]
def gm(t):
pass
[gm.when(default)]
def gm(t):
return 'default'
[gm.when('issubclass(t,int)')]
def gm2(t):
return 'int'
self.assertEqual(gm(int), "int")
self.assertEqual(gm(object), "default")
self.assertEqual(gm(float), "default")
def testKwArgHandling(self):
[dispatch.generic()]
def f(**fiz):
"""Test of kw handling"""
[f.when("'x' in fiz")]
def f(**fiz):
return "x"
[f.when("'y' in fiz")]
def f(**fiz):
return "y"
self.assertEqual(f(x=1), "x")
self.assertEqual(f(y=1), "y")
self.assertRaises(AmbiguousMethod, f, x=1, y=1)
def testSimpleChaining(self):
def both_vehicles(ob1, ob2):
return "They're both vehicles."
def both_land(next_method, ob1, ob2):
return next_method(ob1, ob2) + " They are both land vehicles."
def both_sea(next_method, ob1, ob2):
return next_method(ob1, ob2) + " They are both sea vehicles."
def mixed_vehicles(next_method, ob1, ob2):
return next_method(ob1,ob2)+ \
" One vehicle is a land vehicle, the other is a sea vehicle."
[dispatch.generic()]
def compare(v1, v2):
pass
compare.addMethod([(Vehicle, Vehicle)], both_vehicles)
compare.addMethod([(LandVehicle, LandVehicle)], both_land)
compare.addMethod([(WaterVehicle, WaterVehicle)], both_sea)
compare.addMethod([(LandVehicle, WaterVehicle),
(WaterVehicle, LandVehicle)], mixed_vehicles)
land = Bicycle()
sea = Speedboat()
self.assertEqual(
compare(land, land),
"They're both vehicles. They are both land vehicles.")
self.assertEqual(
compare(sea, sea),
"They're both vehicles. They are both sea vehicles.")
self.assertEqual(
compare(land, sea), "They're both vehicles. \
One vehicle is a land vehicle, the other is a sea vehicle.")
self.assertEqual(
compare(sea, land), "They're both vehicles. \
One vehicle is a land vehicle, the other is a sea vehicle.")
def _build_rules(func):
[generic(CustomDispatch)]
def _expose(func, accept, allow_json, *args, **kw):
pass
if func._allow_json:
log.debug("Adding allow_json rule: "
'allow_json and (kw.get("tg_format", None) == "json"'
' or accept in ("application/json", "text/javascript"))')
_expose.when('allow_json and (kw.get("tg_format", None) == "json"'
' or accept in ("application/json", "text/javascript"))')(
lambda _func, accept, allow_json, *args, **kw:
_execute_func(_func, "json", "json", "application/json",
None, False, args, kw))
found_default = False
for ruleinfo in func._ruleinfo:
found_default = _add_rule(_expose, found_default, **ruleinfo)
func._expose = _expose
def _build_rules(func):
[generic(CustomDispatch)]
def _expose(func, accept, allow_json, *args, **kw):
pass
if func._allow_json:
log.debug("Adding allow_json rule: "
'allow_json and (kw.get("tg_format", None) == "json"'
' or accept in ("application/json", "text/javascript"))')
_expose.when('allow_json and (kw.get("tg_format", None) == "json"'
' or accept in ("application/json", "text/javascript"))')(
lambda _func, accept, allow_json, *args, **kw:
_execute_func(_func, "json", "json", "application/json",
None, False, args, kw))
found_default = False
for ruleinfo in func._ruleinfo:
found_default = _add_rule(_expose, found_default, **ruleinfo)
func._expose = _expose
def testSimpleChaining(self):
def both_vehicles(ob1,ob2):
return "They're both vehicles."
def both_land(next_method,ob1,ob2):
return next_method(ob1,ob2)+" They are both land vehicles."
def both_sea(next_method,ob1,ob2):
return next_method(ob1,ob2)+" They are both sea vehicles."
def mixed_vehicles(next_method,ob1,ob2):
return next_method(ob1,ob2)+ \
" One vehicle is a land vehicle, the other is a sea vehicle."
[dispatch.generic()]
def compare(v1,v2): pass
compare.addMethod([(Vehicle, Vehicle)], both_vehicles)
compare.addMethod([(LandVehicle, LandVehicle)],both_land)
compare.addMethod([(WaterVehicle, WaterVehicle)],both_sea)
compare.addMethod(
[(LandVehicle, WaterVehicle),(WaterVehicle, LandVehicle)],
mixed_vehicles
)
land = Bicycle()
sea = Speedboat()
self.assertEqual( compare(land, land),
"They're both vehicles. They are both land vehicles.")
self.assertEqual( compare(sea, sea),
"They're both vehicles. They are both sea vehicles.")
self.assertEqual( compare(land, sea), "They're both vehicles. \
One vehicle is a land vehicle, the other is a sea vehicle.")
self.assertEqual( compare(sea, land), "They're both vehicles. \
One vehicle is a land vehicle, the other is a sea vehicle.")
def testVarArgHandling(self):
[dispatch.generic()]
def f(*fiz):
"""Test of vararg handling"""
[f.when("'x' in fiz")]
def f(*fiz):
return "x"
[f.when("'y' in fiz")]
def f(*fiz):
return "y"
self.assertEqual(f("foo", "x"), "x")
self.assertEqual(f("bar", "q", "y"), "y")
self.assertEqual(f("bar", "q", "y"), "y")
self.assertEqual(f(
"y",
"q",
), "y")
self.assertRaises(AmbiguousMethod, f, "x", "y")
import unittest
from dispatch import generic
from turbogears.genericfunctions import *
mo_state = []
[generic(MultiorderGenericFunction)]
def mo(a):
pass
[mo.when("a>0", order=2)]
def mo2(next_method, a):
mo_state.append(2)
[mo.when("a>0")]
def mo0(next_method, a):
mo_state.append(0)
return next_method(a)
[mo.when("a>0", order=1)]
def mo1(next_method, a):
mo_state.append(1)
return next_method(a)
[mo.around("a<23")]
def moa0(next_method, a):
mo_state.append("a")
return next_method(a)
import unittest
from dispatch import generic
from turbogears.genericfunctions import *
mo_state = []
def mo(a):
pass
mo = generic(MultiorderGenericFunction)(mo)
def mo2(next_method, a):
mo_state.append(2)
mo2 = mo.when("a>0", order=2)(mo2)
def mo0(next_method, a):
mo_state.append(0)
return next_method(a)
mo0 = mo.when("a>0")(mo0)
def mo1(next_method, a):
mo_state.append(1)
return next_method(a)
mo1 = mo.when("a>0", order=1)(mo1)
def moa0(next_method, a):
mo_state.append("a")
return next_method(a)
moa0 = mo.around("a<23")(moa0)
# 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 dispatch
def create(class_, **kw):
"Returns a new class_ object created using the keyword arguments."
raise NotImplementedError
create = dispatch.generic()(create)
def retrieve(class_, **kw):
"""Returns a list of existing class_ objects using the keyword arguments.
Should return an empty list if there are no matching objects.
If no keywords are provided, should return all class_ objects."""
raise NotImplementedError
retrieve = dispatch.generic()(retrieve)
def retrieve_one(class_, **kw):
"""Returns a single class_ object using the keyword arguments.
Should return None if there is no matching object.
Should raise a LookupError when more than one object
matches."""
from turbogears.util import inject_args, adapt_call, call_on_stack, has_arg, \
remove_keys, Enum, combine_contexts
from turbogears.decorator import func_eq
from turbogears.genericfunctions import MultiorderGenericFunction
default = strategy.default
def dispatch_error(controller, tg_source, tg_errors, tg_exceptions,
*args, **kw):
"""Dispatch error.
Error handler is a function registered via register_handler or if no
such decorator was applied, the method triggering the error.
"""
dispatch_error = generic(MultiorderGenericFunction)(dispatch_error)
def _register_implicit_errh(controller, tg_source, tg_errors,
tg_exceptions, *args, **kw):
"""Register implicitly declared error handler and re-dispatch.
Any method declaring tg_errors parameter is considered an implicitly
declared error handler.
"""
error_handler(tg_source)(tg_source)
return dispatch_error(controller, tg_source, tg_errors, tg_exceptions,
*args, **kw)
_register_implicit_errh = dispatch_error.when(
"(tg_errors and has_arg(tg_source, 'tg_errors'))", order=3)(
_register_implicit_errh)
hub.commit()
def rollback_all():
"""Rollback the transactions in all registered hubs (for this thread)."""
for hub in hub_registry:
hub.rollback()
def end_all():
"""End the transactions in all registered hubs (for this thread)."""
for hub in hub_registry:
hub.end()
[dispatch.generic(MultiorderGenericFunction)]
def run_with_transaction(func, *args, **kw):
pass
[dispatch.generic(MultiorderGenericFunction)]
def restart_transaction(args):
pass
def _use_sa(args=None):
# check to see if sqlalchemy has been imported and configured
# @@: This is experimental
import warnings
warnings.warn("formencode.formgen is deprecated with no replacement; "
"if you are using it please maintain your own copy of this "
"file", DeprecationWarning, 2)
import fields
dispatch = None
try:
import pkg_resources
pkg_resources.require('RuleDispatch')
import dispatch
except ImportError:
pass
if dispatch:
#@dispatch.generic()
def makeform(obj, context):
"""
Return ``(field_obj, Schema)``.
Return a field or field container used to edit ``obj`` given the
context. Also return a Schema object (or None for no Schema) that
will be applied before other validation.
"""
raise NotImplementedError
makeform = dispatch.generic()(makeform)
import unittest
from dispatch import generic
from turbogears.genericfunctions import *
mo_state = []
[generic(MultiorderGenericFunction)]
def mo(a):
pass
[mo.when("a>0", order=2)]
def mo2(next_method, a):
mo_state.append(2)
[mo.when("a>0")]
def mo0(next_method, a):
mo_state.append(0)
return next_method(a)
[mo.when("a>0", order=1)]
# @@: This is experimental
import warnings
warnings.warn(
"formencode.formgen is deprecated with no replacement; "
"if you are using it please maintain your own copy of this "
"file", DeprecationWarning, 2)
import fields
dispatch = None
try:
import pkg_resources
pkg_resources.require('RuleDispatch')
import dispatch
except ImportError:
pass
if dispatch:
#@dispatch.generic()
def makeform(obj, context):
"""
Return ``(field_obj, Schema)``.
Return a field or field container used to edit ``obj`` given the
context. Also return a Schema object (or None for no Schema) that
will be applied before other validation.
"""
raise NotImplementedError
makeform = dispatch.generic()(makeform)
import decimal
except ImportError:
# Python 2.3
decimal = None
def jsonify(obj):
"""
Return an object that can be serialized with JSON, i.e., it
is made up of only lists, dictionaries (with string keys),
and strings, ints, and floats.
"""
raise NotImplementedError
jsonify = dispatch.generic()(jsonify)
def jsonify_datetime(obj):
return str(obj)
jsonify_datetime = jsonify.when("isinstance(obj, datetime.datetime) or " "isinstance(obj, datetime.date)")(
jsonify_datetime
)
def jsonify_decimal(obj):
return float(obj)
def commit_all():
"Commits the Transactions in all registered hubs (for this thread)"
for hub in hub_registry:
hub.commit()
def rollback_all():
"Rolls back the Transactions in all registered hubs (for this thread)"
for hub in hub_registry:
hub.rollback()
def end_all():
"Ends the Transactions in all registered hubs (for this thread)"
for hub in hub_registry:
hub.end()
[dispatch.generic(MultiorderGenericFunction)]
def run_with_transaction(func, *args, **kw):
pass
def _use_sa(args=None):
# check to see if sqlalchemy has been imported and configured
return _engine is not None
[run_with_transaction.when("not _use_sa(args)")] # include "args" to avoid call being pre-cached
def so_rwt(func, *args, **kw):
log.debug("Starting SQLObject transaction")
try:
try:
retval = func(*args, **kw)
commit_all()
return retval
import dispatch
from turbogears import config
from turbogears.util import get_model
try:
from sqlalchemy import MetaData, exceptions, Table, String, Unicode
from turbogears.database import metadata, get_engine
except ImportError: # if not available, complain only at run-time
get_engine = None
else:
try:
from sqlalchemy import Text, UnicodeText
except ImportError: # SQLAlchemy < 0.4.3
Text, UnicodeText = String, Unicode
[dispatch.generic()]
def sacommand(command, args):
pass
[sacommand.around("command and command != 'help' and not get_engine")]
def no_engine(command, args):
print "Error: SQLAlchemy not installed."
[sacommand.when("command == 'help'")]
import dispatch
from turbogears import config
from turbogears.util import get_model
try:
from sqlalchemy import MetaData, exceptions, Table, String, Unicode
from turbogears.database import metadata, get_engine
except ImportError: # if not available, complain only at run-time
get_engine = None
else:
try:
from sqlalchemy import Text, UnicodeText
except ImportError: # SQLAlchemy < 0.4.3
Text, UnicodeText = String, Unicode
[dispatch.generic()]
def sacommand(command, args):
pass
[sacommand.around("command and command != 'help' and not get_engine")]
def no_engine(command, args):
print "Error: SQLAlchemy not installed."
[sacommand.when("command == 'help'")]
def help(command, args):
print """TurboGears SQLAlchemy Helper
tg-admin sql command [options]
Available commands:
create Create tables
execute Execute SQL statements
"""Schevo field SQL operations.
For copyright, license, and warranty, see bottom of file.
"""
from dispatch import generic
from schevo.constant import UNASSIGNED
from schevo import field as F
[generic()]
def to_colspec(dialect, field):
"""Return a tuple of (specs, constraints) for the field."""
[generic()]
def to_data(dialect, field):
"""Return a tuple of (col name, value) suitable for INSERT."""
# --------------------------------------------------------------------
[to_colspec.when("dialect == 'jet' and isinstance(field, F.Field)")]
def to_colspec(dialect, field):
if field.max_size is not None:
max_size = '(%i)' % field.max_size
else:
max_size = ''
specs = [
