[3] | 1 | """Utility functions and classes used by nose internally. |
---|
| 2 | """ |
---|
| 3 | import inspect |
---|
| 4 | import itertools |
---|
| 5 | import logging |
---|
| 6 | import os |
---|
| 7 | import re |
---|
| 8 | import sys |
---|
| 9 | import types |
---|
| 10 | import unittest |
---|
| 11 | from types import ClassType, TypeType |
---|
| 12 | |
---|
| 13 | try: |
---|
| 14 | from compiler.consts import CO_GENERATOR |
---|
| 15 | except ImportError: |
---|
| 16 | # IronPython doesn't have a complier module |
---|
| 17 | CO_GENERATOR=0x20 |
---|
| 18 | |
---|
| 19 | log = logging.getLogger('nose') |
---|
| 20 | |
---|
| 21 | ident_re = re.compile(r'^[A-Za-z_][A-Za-z0-9_.]*$') |
---|
| 22 | class_types = (ClassType, TypeType) |
---|
| 23 | skip_pattern = r"(?:\.svn)|(?:[^.]+\.py[co])|(?:.*~)|(?:.*\$py\.class)" |
---|
| 24 | |
---|
| 25 | try: |
---|
| 26 | set() |
---|
| 27 | set = set # make from nose.util import set happy |
---|
| 28 | except NameError: |
---|
| 29 | try: |
---|
| 30 | from sets import Set as set |
---|
| 31 | except ImportError: |
---|
| 32 | pass |
---|
| 33 | |
---|
| 34 | |
---|
| 35 | def ls_tree(dir_path="", |
---|
| 36 | skip_pattern=skip_pattern, |
---|
| 37 | indent="|-- ", branch_indent="| ", |
---|
| 38 | last_indent="`-- ", last_branch_indent=" "): |
---|
| 39 | # TODO: empty directories look like non-directory files |
---|
| 40 | return "\n".join(_ls_tree_lines(dir_path, skip_pattern, |
---|
| 41 | indent, branch_indent, |
---|
| 42 | last_indent, last_branch_indent)) |
---|
| 43 | |
---|
| 44 | |
---|
| 45 | def _ls_tree_lines(dir_path, skip_pattern, |
---|
| 46 | indent, branch_indent, last_indent, last_branch_indent): |
---|
| 47 | if dir_path == "": |
---|
| 48 | dir_path = os.getcwd() |
---|
| 49 | |
---|
| 50 | lines = [] |
---|
| 51 | |
---|
| 52 | names = os.listdir(dir_path) |
---|
| 53 | names.sort() |
---|
| 54 | dirs, nondirs = [], [] |
---|
| 55 | for name in names: |
---|
| 56 | if re.match(skip_pattern, name): |
---|
| 57 | continue |
---|
| 58 | if os.path.isdir(os.path.join(dir_path, name)): |
---|
| 59 | dirs.append(name) |
---|
| 60 | else: |
---|
| 61 | nondirs.append(name) |
---|
| 62 | |
---|
| 63 | # list non-directories first |
---|
| 64 | entries = list(itertools.chain([(name, False) for name in nondirs], |
---|
| 65 | [(name, True) for name in dirs])) |
---|
| 66 | def ls_entry(name, is_dir, ind, branch_ind): |
---|
| 67 | if not is_dir: |
---|
| 68 | yield ind + name |
---|
| 69 | else: |
---|
| 70 | path = os.path.join(dir_path, name) |
---|
| 71 | if not os.path.islink(path): |
---|
| 72 | yield ind + name |
---|
| 73 | subtree = _ls_tree_lines(path, skip_pattern, |
---|
| 74 | indent, branch_indent, |
---|
| 75 | last_indent, last_branch_indent) |
---|
| 76 | for x in subtree: |
---|
| 77 | yield branch_ind + x |
---|
| 78 | for name, is_dir in entries[:-1]: |
---|
| 79 | for line in ls_entry(name, is_dir, indent, branch_indent): |
---|
| 80 | yield line |
---|
| 81 | if entries: |
---|
| 82 | name, is_dir = entries[-1] |
---|
| 83 | for line in ls_entry(name, is_dir, last_indent, last_branch_indent): |
---|
| 84 | yield line |
---|
| 85 | |
---|
| 86 | |
---|
| 87 | def absdir(path): |
---|
| 88 | """Return absolute, normalized path to directory, if it exists; None |
---|
| 89 | otherwise. |
---|
| 90 | """ |
---|
| 91 | if not os.path.isabs(path): |
---|
| 92 | path = os.path.normpath(os.path.abspath(os.path.join(os.getcwd(), |
---|
| 93 | path))) |
---|
| 94 | if path is None or not os.path.isdir(path): |
---|
| 95 | return None |
---|
| 96 | return path |
---|
| 97 | |
---|
| 98 | |
---|
| 99 | def absfile(path, where=None): |
---|
| 100 | """Return absolute, normalized path to file (optionally in directory |
---|
| 101 | where), or None if the file can't be found either in where or the current |
---|
| 102 | working directory. |
---|
| 103 | """ |
---|
| 104 | orig = path |
---|
| 105 | if where is None: |
---|
| 106 | where = os.getcwd() |
---|
| 107 | if isinstance(where, list) or isinstance(where, tuple): |
---|
| 108 | for maybe_path in where: |
---|
| 109 | maybe_abs = absfile(path, maybe_path) |
---|
| 110 | if maybe_abs is not None: |
---|
| 111 | return maybe_abs |
---|
| 112 | return None |
---|
| 113 | if not os.path.isabs(path): |
---|
| 114 | path = os.path.normpath(os.path.abspath(os.path.join(where, path))) |
---|
| 115 | if path is None or not os.path.exists(path): |
---|
| 116 | if where != os.getcwd(): |
---|
| 117 | # try the cwd instead |
---|
| 118 | path = os.path.normpath(os.path.abspath(os.path.join(os.getcwd(), |
---|
| 119 | orig))) |
---|
| 120 | if path is None or not os.path.exists(path): |
---|
| 121 | return None |
---|
| 122 | if os.path.isdir(path): |
---|
| 123 | # might want an __init__.py from pacakge |
---|
| 124 | init = os.path.join(path,'__init__.py') |
---|
| 125 | if os.path.isfile(init): |
---|
| 126 | return init |
---|
| 127 | elif os.path.isfile(path): |
---|
| 128 | return path |
---|
| 129 | return None |
---|
| 130 | |
---|
| 131 | |
---|
| 132 | def anyp(predicate, iterable): |
---|
| 133 | for item in iterable: |
---|
| 134 | if predicate(item): |
---|
| 135 | return True |
---|
| 136 | return False |
---|
| 137 | |
---|
| 138 | |
---|
| 139 | def file_like(name): |
---|
| 140 | """A name is file-like if it is a path that exists, or it has a |
---|
| 141 | directory part, or it ends in .py, or it isn't a legal python |
---|
| 142 | identifier. |
---|
| 143 | """ |
---|
| 144 | return (os.path.exists(name) |
---|
| 145 | or os.path.dirname(name) |
---|
| 146 | or name.endswith('.py') |
---|
| 147 | or not ident_re.match(os.path.splitext(name)[0])) |
---|
| 148 | |
---|
| 149 | |
---|
| 150 | def cmp_lineno(a, b): |
---|
| 151 | """Compare functions by their line numbers. |
---|
| 152 | |
---|
| 153 | >>> cmp_lineno(isgenerator, ispackage) |
---|
| 154 | -1 |
---|
| 155 | >>> cmp_lineno(ispackage, isgenerator) |
---|
| 156 | 1 |
---|
| 157 | >>> cmp_lineno(isgenerator, isgenerator) |
---|
| 158 | 0 |
---|
| 159 | """ |
---|
| 160 | return cmp(func_lineno(a), func_lineno(b)) |
---|
| 161 | |
---|
| 162 | |
---|
| 163 | def func_lineno(func): |
---|
| 164 | """Get the line number of a function. First looks for |
---|
| 165 | compat_co_firstlineno, then func_code.co_first_lineno. |
---|
| 166 | """ |
---|
| 167 | try: |
---|
| 168 | return func.compat_co_firstlineno |
---|
| 169 | except AttributeError: |
---|
| 170 | try: |
---|
| 171 | return func.func_code.co_firstlineno |
---|
| 172 | except AttributeError: |
---|
| 173 | return -1 |
---|
| 174 | |
---|
| 175 | |
---|
| 176 | def isclass(obj): |
---|
| 177 | """Is obj a class? Inspect's isclass is too liberal and returns True |
---|
| 178 | for objects that can't be subclasses of anything. |
---|
| 179 | """ |
---|
| 180 | obj_type = type(obj) |
---|
| 181 | return obj_type in class_types or issubclass(obj_type, type) |
---|
| 182 | |
---|
| 183 | |
---|
| 184 | def isgenerator(func): |
---|
| 185 | try: |
---|
| 186 | return func.func_code.co_flags & CO_GENERATOR != 0 |
---|
| 187 | except AttributeError: |
---|
| 188 | return False |
---|
| 189 | # backwards compat (issue #64) |
---|
| 190 | is_generator = isgenerator |
---|
| 191 | |
---|
| 192 | |
---|
| 193 | def ispackage(path): |
---|
| 194 | """ |
---|
| 195 | Is this path a package directory? |
---|
| 196 | |
---|
| 197 | >>> ispackage('nose') |
---|
| 198 | True |
---|
| 199 | >>> ispackage('unit_tests') |
---|
| 200 | False |
---|
| 201 | >>> ispackage('nose/plugins') |
---|
| 202 | True |
---|
| 203 | >>> ispackage('nose/loader.py') |
---|
| 204 | False |
---|
| 205 | """ |
---|
| 206 | if os.path.isdir(path): |
---|
| 207 | # at least the end of the path must be a legal python identifier |
---|
| 208 | # and __init__.py[co] must exist |
---|
| 209 | end = os.path.basename(path) |
---|
| 210 | if ident_re.match(end): |
---|
| 211 | for init in ('__init__.py', '__init__.pyc', '__init__.pyo'): |
---|
| 212 | if os.path.isfile(os.path.join(path, init)): |
---|
| 213 | return True |
---|
| 214 | if sys.platform.startswith('java') and \ |
---|
| 215 | os.path.isfile(os.path.join(path, '__init__$py.class')): |
---|
| 216 | return True |
---|
| 217 | return False |
---|
| 218 | |
---|
| 219 | |
---|
| 220 | def isproperty(obj): |
---|
| 221 | """ |
---|
| 222 | Is this a property? |
---|
| 223 | |
---|
| 224 | >>> class Foo: |
---|
| 225 | ... def got(self): |
---|
| 226 | ... return 2 |
---|
| 227 | ... def get(self): |
---|
| 228 | ... return 1 |
---|
| 229 | ... get = property(get) |
---|
| 230 | |
---|
| 231 | >>> isproperty(Foo.got) |
---|
| 232 | False |
---|
| 233 | >>> isproperty(Foo.get) |
---|
| 234 | True |
---|
| 235 | """ |
---|
| 236 | return type(obj) == property |
---|
| 237 | |
---|
| 238 | |
---|
| 239 | def getfilename(package, relativeTo=None): |
---|
| 240 | """Find the python source file for a package, relative to a |
---|
| 241 | particular directory (defaults to current working directory if not |
---|
| 242 | given). |
---|
| 243 | """ |
---|
| 244 | if relativeTo is None: |
---|
| 245 | relativeTo = os.getcwd() |
---|
| 246 | path = os.path.join(relativeTo, os.sep.join(package.split('.'))) |
---|
| 247 | suffixes = ('/__init__.py', '.py') |
---|
| 248 | for suffix in suffixes: |
---|
| 249 | filename = path + suffix |
---|
| 250 | if os.path.exists(filename): |
---|
| 251 | return filename |
---|
| 252 | return None |
---|
| 253 | |
---|
| 254 | |
---|
| 255 | def getpackage(filename): |
---|
| 256 | """ |
---|
| 257 | Find the full dotted package name for a given python source file |
---|
| 258 | name. Returns None if the file is not a python source file. |
---|
| 259 | |
---|
| 260 | >>> getpackage('foo.py') |
---|
| 261 | 'foo' |
---|
| 262 | >>> getpackage('biff/baf.py') |
---|
| 263 | 'baf' |
---|
| 264 | >>> getpackage('nose/util.py') |
---|
| 265 | 'nose.util' |
---|
| 266 | |
---|
| 267 | Works for directories too. |
---|
| 268 | |
---|
| 269 | >>> getpackage('nose') |
---|
| 270 | 'nose' |
---|
| 271 | >>> getpackage('nose/plugins') |
---|
| 272 | 'nose.plugins' |
---|
| 273 | |
---|
| 274 | And __init__ files stuck onto directories |
---|
| 275 | |
---|
| 276 | >>> getpackage('nose/plugins/__init__.py') |
---|
| 277 | 'nose.plugins' |
---|
| 278 | |
---|
| 279 | Absolute paths also work. |
---|
| 280 | |
---|
| 281 | >>> path = os.path.abspath(os.path.join('nose', 'plugins')) |
---|
| 282 | >>> getpackage(path) |
---|
| 283 | 'nose.plugins' |
---|
| 284 | """ |
---|
| 285 | src_file = src(filename) |
---|
| 286 | if not src_file.endswith('.py') and not ispackage(src_file): |
---|
| 287 | return None |
---|
| 288 | base, ext = os.path.splitext(os.path.basename(src_file)) |
---|
| 289 | if base == '__init__': |
---|
| 290 | mod_parts = [] |
---|
| 291 | else: |
---|
| 292 | mod_parts = [base] |
---|
| 293 | path, part = os.path.split(os.path.split(src_file)[0]) |
---|
| 294 | while part: |
---|
| 295 | if ispackage(os.path.join(path, part)): |
---|
| 296 | mod_parts.append(part) |
---|
| 297 | else: |
---|
| 298 | break |
---|
| 299 | path, part = os.path.split(path) |
---|
| 300 | mod_parts.reverse() |
---|
| 301 | return '.'.join(mod_parts) |
---|
| 302 | |
---|
| 303 | |
---|
| 304 | def ln(label): |
---|
| 305 | """Draw a 70-char-wide divider, with label in the middle. |
---|
| 306 | |
---|
| 307 | >>> ln('hello there') |
---|
| 308 | '---------------------------- hello there -----------------------------' |
---|
| 309 | """ |
---|
| 310 | label_len = len(label) + 2 |
---|
| 311 | chunk = (70 - label_len) / 2 |
---|
| 312 | out = '%s %s %s' % ('-' * chunk, label, '-' * chunk) |
---|
| 313 | pad = 70 - len(out) |
---|
| 314 | if pad > 0: |
---|
| 315 | out = out + ('-' * pad) |
---|
| 316 | return out |
---|
| 317 | |
---|
| 318 | |
---|
| 319 | def resolve_name(name, module=None): |
---|
| 320 | """Resolve a dotted name to a module and its parts. This is stolen |
---|
| 321 | wholesale from unittest.TestLoader.loadTestByName. |
---|
| 322 | |
---|
| 323 | >>> resolve_name('nose.util') #doctest: +ELLIPSIS |
---|
| 324 | <module 'nose.util' from...> |
---|
| 325 | >>> resolve_name('nose.util.resolve_name') #doctest: +ELLIPSIS |
---|
| 326 | <function resolve_name at...> |
---|
| 327 | """ |
---|
| 328 | parts = name.split('.') |
---|
| 329 | parts_copy = parts[:] |
---|
| 330 | if module is None: |
---|
| 331 | while parts_copy: |
---|
| 332 | try: |
---|
| 333 | log.debug("__import__ %s", name) |
---|
| 334 | module = __import__('.'.join(parts_copy)) |
---|
| 335 | break |
---|
| 336 | except ImportError: |
---|
| 337 | del parts_copy[-1] |
---|
| 338 | if not parts_copy: |
---|
| 339 | raise |
---|
| 340 | parts = parts[1:] |
---|
| 341 | obj = module |
---|
| 342 | log.debug("resolve: %s, %s, %s, %s", parts, name, obj, module) |
---|
| 343 | for part in parts: |
---|
| 344 | obj = getattr(obj, part) |
---|
| 345 | return obj |
---|
| 346 | |
---|
| 347 | |
---|
| 348 | def split_test_name(test): |
---|
| 349 | """Split a test name into a 3-tuple containing file, module, and callable |
---|
| 350 | names, any of which (but not all) may be blank. |
---|
| 351 | |
---|
| 352 | Test names are in the form: |
---|
| 353 | |
---|
| 354 | file_or_module:callable |
---|
| 355 | |
---|
| 356 | Either side of the : may be dotted. To change the splitting behavior, you |
---|
| 357 | can alter nose.util.split_test_re. |
---|
| 358 | """ |
---|
| 359 | norm = os.path.normpath |
---|
| 360 | file_or_mod = test |
---|
| 361 | fn = None |
---|
| 362 | if not ':' in test: |
---|
| 363 | # only a file or mod part |
---|
| 364 | if file_like(test): |
---|
| 365 | return (norm(test), None, None) |
---|
| 366 | else: |
---|
| 367 | return (None, test, None) |
---|
| 368 | |
---|
| 369 | # could be path|mod:callable, or a : in the file path someplace |
---|
| 370 | head, tail = os.path.split(test) |
---|
| 371 | if not head: |
---|
| 372 | # this is a case like 'foo:bar' -- generally a module |
---|
| 373 | # name followed by a callable, but also may be a windows |
---|
| 374 | # drive letter followed by a path |
---|
| 375 | try: |
---|
| 376 | file_or_mod, fn = test.split(':') |
---|
| 377 | if file_like(fn): |
---|
| 378 | # must be a funny path |
---|
| 379 | file_or_mod, fn = test, None |
---|
| 380 | except ValueError: |
---|
| 381 | # more than one : in the test |
---|
| 382 | # this is a case like c:\some\path.py:a_test |
---|
| 383 | parts = test.split(':') |
---|
| 384 | if len(parts[0]) == 1: |
---|
| 385 | file_or_mod, fn = ':'.join(parts[:-1]), parts[-1] |
---|
| 386 | else: |
---|
| 387 | # nonsense like foo:bar:baz |
---|
| 388 | raise ValueError("Test name '%s' could not be parsed. Please " |
---|
| 389 | "format test names as path:callable or " |
---|
| 390 | "module:callable.") |
---|
| 391 | elif not tail: |
---|
| 392 | # this is a case like 'foo:bar/' |
---|
| 393 | # : must be part of the file path, so ignore it |
---|
| 394 | file_or_mod = test |
---|
| 395 | else: |
---|
| 396 | if ':' in tail: |
---|
| 397 | file_part, fn = tail.split(':') |
---|
| 398 | else: |
---|
| 399 | file_part = tail |
---|
| 400 | file_or_mod = os.sep.join([head, file_part]) |
---|
| 401 | if file_or_mod: |
---|
| 402 | if file_like(file_or_mod): |
---|
| 403 | return (norm(file_or_mod), None, fn) |
---|
| 404 | else: |
---|
| 405 | return (None, file_or_mod, fn) |
---|
| 406 | else: |
---|
| 407 | return (None, None, fn) |
---|
| 408 | split_test_name.__test__ = False # do not collect |
---|
| 409 | |
---|
| 410 | |
---|
| 411 | def test_address(test): |
---|
| 412 | """Find the test address for a test, which may be a module, filename, |
---|
| 413 | class, method or function. |
---|
| 414 | """ |
---|
| 415 | if hasattr(test, "address"): |
---|
| 416 | return test.address() |
---|
| 417 | # type-based polymorphism sucks in general, but I believe is |
---|
| 418 | # appropriate here |
---|
| 419 | t = type(test) |
---|
| 420 | file = module = call = None |
---|
| 421 | if t == types.ModuleType: |
---|
| 422 | file = getattr(test, '__file__', None) |
---|
| 423 | module = getattr(test, '__name__', None) |
---|
| 424 | return (src(file), module, call) |
---|
| 425 | if t == types.FunctionType or issubclass(t, type) or t == types.ClassType: |
---|
| 426 | module = getattr(test, '__module__', None) |
---|
| 427 | if module is not None: |
---|
| 428 | m = sys.modules[module] |
---|
| 429 | file = getattr(m, '__file__', None) |
---|
| 430 | if file is not None: |
---|
| 431 | file = os.path.abspath(file) |
---|
| 432 | call = getattr(test, '__name__', None) |
---|
| 433 | return (src(file), module, call) |
---|
| 434 | if t == types.InstanceType: |
---|
| 435 | return test_address(test.__class__) |
---|
| 436 | if t == types.MethodType: |
---|
| 437 | cls_adr = test_address(test.im_class) |
---|
| 438 | return (src(cls_adr[0]), cls_adr[1], |
---|
| 439 | "%s.%s" % (cls_adr[2], test.__name__)) |
---|
| 440 | # handle unittest.TestCase instances |
---|
| 441 | if isinstance(test, unittest.TestCase): |
---|
| 442 | if hasattr(test, '_FunctionTestCase__testFunc'): |
---|
| 443 | # unittest FunctionTestCase |
---|
| 444 | return test_address(test._FunctionTestCase__testFunc) |
---|
| 445 | # regular unittest.TestCase |
---|
| 446 | cls_adr = test_address(test.__class__) |
---|
| 447 | # 2.5 compat: __testMethodName changed to _testMethodName |
---|
| 448 | try: |
---|
| 449 | method_name = test._TestCase__testMethodName |
---|
| 450 | except AttributeError: |
---|
| 451 | method_name = test._testMethodName |
---|
| 452 | return (src(cls_adr[0]), cls_adr[1], |
---|
| 453 | "%s.%s" % (cls_adr[2], method_name)) |
---|
| 454 | raise TypeError("I don't know what %s is (%s)" % (test, t)) |
---|
| 455 | test_address.__test__ = False # do not collect |
---|
| 456 | |
---|
| 457 | |
---|
| 458 | def try_run(obj, names): |
---|
| 459 | """Given a list of possible method names, try to run them with the |
---|
| 460 | provided object. Keep going until something works. Used to run |
---|
| 461 | setup/teardown methods for module, package, and function tests. |
---|
| 462 | """ |
---|
| 463 | for name in names: |
---|
| 464 | func = getattr(obj, name, None) |
---|
| 465 | if func is not None: |
---|
| 466 | if type(obj) == types.ModuleType: |
---|
| 467 | # py.test compatibility |
---|
| 468 | try: |
---|
| 469 | args, varargs, varkw, defaults = inspect.getargspec(func) |
---|
| 470 | except TypeError: |
---|
| 471 | # Not a function. If it's callable, call it anyway |
---|
| 472 | if hasattr(func, '__call__'): |
---|
| 473 | func = func.__call__ |
---|
| 474 | try: |
---|
| 475 | args, varargs, varkw, defaults = \ |
---|
| 476 | inspect.getargspec(func) |
---|
| 477 | args.pop(0) # pop the self off |
---|
| 478 | except TypeError: |
---|
| 479 | raise TypeError("Attribute %s of %r is not a python " |
---|
| 480 | "function. Only functions or callables" |
---|
| 481 | " may be used as fixtures." % |
---|
| 482 | (name, obj)) |
---|
| 483 | if len(args): |
---|
| 484 | log.debug("call fixture %s.%s(%s)", obj, name, obj) |
---|
| 485 | return func(obj) |
---|
| 486 | log.debug("call fixture %s.%s", obj, name) |
---|
| 487 | return func() |
---|
| 488 | |
---|
| 489 | |
---|
| 490 | def src(filename): |
---|
| 491 | """Find the python source file for a .pyc, .pyo or $py.class file on |
---|
| 492 | jython. Returns the filename provided if it is not a python source |
---|
| 493 | file. |
---|
| 494 | """ |
---|
| 495 | if filename is None: |
---|
| 496 | return filename |
---|
| 497 | if sys.platform.startswith('java') and filename.endswith('$py.class'): |
---|
| 498 | return '.'.join((filename[:-9], 'py')) |
---|
| 499 | base, ext = os.path.splitext(filename) |
---|
| 500 | if ext in ('.pyc', '.pyo', '.py'): |
---|
| 501 | return '.'.join((base, 'py')) |
---|
| 502 | return filename |
---|
| 503 | |
---|
| 504 | |
---|
| 505 | def match_last(a, b, regex): |
---|
| 506 | """Sort compare function that puts items that match a |
---|
| 507 | regular expression last. |
---|
| 508 | |
---|
| 509 | >>> from nose.config import Config |
---|
| 510 | >>> c = Config() |
---|
| 511 | >>> regex = c.testMatch |
---|
| 512 | >>> entries = ['.', '..', 'a_test', 'src', 'lib', 'test', 'foo.py'] |
---|
| 513 | >>> entries.sort(lambda a, b: match_last(a, b, regex)) |
---|
| 514 | >>> entries |
---|
| 515 | ['.', '..', 'foo.py', 'lib', 'src', 'a_test', 'test'] |
---|
| 516 | """ |
---|
| 517 | if regex.search(a) and not regex.search(b): |
---|
| 518 | return 1 |
---|
| 519 | elif regex.search(b) and not regex.search(a): |
---|
| 520 | return -1 |
---|
| 521 | return cmp(a, b) |
---|
| 522 | |
---|
| 523 | |
---|
| 524 | def tolist(val): |
---|
| 525 | """Convert a value that may be a list or a (possibly comma-separated) |
---|
| 526 | string into a list. The exception: None is returned as None, not [None]. |
---|
| 527 | |
---|
| 528 | >>> tolist(["one", "two"]) |
---|
| 529 | ['one', 'two'] |
---|
| 530 | >>> tolist("hello") |
---|
| 531 | ['hello'] |
---|
| 532 | >>> tolist("separate,values, with, commas, spaces , are ,ok") |
---|
| 533 | ['separate', 'values', 'with', 'commas', 'spaces', 'are', 'ok'] |
---|
| 534 | """ |
---|
| 535 | if val is None: |
---|
| 536 | return None |
---|
| 537 | try: |
---|
| 538 | # might already be a list |
---|
| 539 | val.extend([]) |
---|
| 540 | return val |
---|
| 541 | except AttributeError: |
---|
| 542 | pass |
---|
| 543 | # might be a string |
---|
| 544 | try: |
---|
| 545 | return re.split(r'\s*,\s*', val) |
---|
| 546 | except TypeError: |
---|
| 547 | # who knows... |
---|
| 548 | return list(val) |
---|
| 549 | |
---|
| 550 | |
---|
| 551 | class odict(dict): |
---|
| 552 | """Simple ordered dict implementation, based on: |
---|
| 553 | |
---|
| 554 | http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/107747 |
---|
| 555 | """ |
---|
| 556 | def __init__(self, *arg, **kw): |
---|
| 557 | self._keys = [] |
---|
| 558 | super(odict, self).__init__(*arg, **kw) |
---|
| 559 | |
---|
| 560 | def __delitem__(self, key): |
---|
| 561 | super(odict, self).__delitem__(key) |
---|
| 562 | self._keys.remove(key) |
---|
| 563 | |
---|
| 564 | def __setitem__(self, key, item): |
---|
| 565 | super(odict, self).__setitem__(key, item) |
---|
| 566 | if key not in self._keys: |
---|
| 567 | self._keys.append(key) |
---|
| 568 | |
---|
| 569 | def __str__(self): |
---|
| 570 | return "{%s}" % ', '.join(["%r: %r" % (k, v) for k, v in self.items()]) |
---|
| 571 | |
---|
| 572 | def clear(self): |
---|
| 573 | super(odict, self).clear() |
---|
| 574 | self._keys = [] |
---|
| 575 | |
---|
| 576 | def copy(self): |
---|
| 577 | d = super(odict, self).copy() |
---|
| 578 | d._keys = self._keys[:] |
---|
| 579 | return d |
---|
| 580 | |
---|
| 581 | def items(self): |
---|
| 582 | return zip(self._keys, self.values()) |
---|
| 583 | |
---|
| 584 | def keys(self): |
---|
| 585 | return self._keys[:] |
---|
| 586 | |
---|
| 587 | def setdefault(self, key, failobj=None): |
---|
| 588 | item = super(odict, self).setdefault(key, failobj) |
---|
| 589 | if key not in self._keys: |
---|
| 590 | self._keys.append(key) |
---|
| 591 | return item |
---|
| 592 | |
---|
| 593 | def update(self, dict): |
---|
| 594 | super(odict, self).update(dict) |
---|
| 595 | for key in dict.keys(): |
---|
| 596 | if key not in self._keys: |
---|
| 597 | self._keys.append(key) |
---|
| 598 | |
---|
| 599 | def values(self): |
---|
| 600 | return map(self.get, self._keys) |
---|
| 601 | |
---|
| 602 | |
---|
| 603 | def transplant_func(func, module): |
---|
| 604 | """ |
---|
| 605 | Make a function imported from module A appear as if it is located |
---|
| 606 | in module B. |
---|
| 607 | |
---|
| 608 | >>> from pprint import pprint |
---|
| 609 | >>> pprint.__module__ |
---|
| 610 | 'pprint' |
---|
| 611 | >>> pp = transplant_func(pprint, __name__) |
---|
| 612 | >>> pp.__module__ |
---|
| 613 | 'nose.util' |
---|
| 614 | |
---|
| 615 | The original function is not modified. |
---|
| 616 | |
---|
| 617 | >>> pprint.__module__ |
---|
| 618 | 'pprint' |
---|
| 619 | |
---|
| 620 | Calling the transplanted function calls the original. |
---|
| 621 | |
---|
| 622 | >>> pp([1, 2]) |
---|
| 623 | [1, 2] |
---|
| 624 | >>> pprint([1,2]) |
---|
| 625 | [1, 2] |
---|
| 626 | |
---|
| 627 | """ |
---|
| 628 | from nose.tools import make_decorator |
---|
| 629 | def newfunc(*arg, **kw): |
---|
| 630 | return func(*arg, **kw) |
---|
| 631 | |
---|
| 632 | newfunc = make_decorator(func)(newfunc) |
---|
| 633 | newfunc.__module__ = module |
---|
| 634 | return newfunc |
---|
| 635 | |
---|
| 636 | |
---|
| 637 | def transplant_class(cls, module): |
---|
| 638 | """ |
---|
| 639 | Make a class appear to reside in `module`, rather than the module in which |
---|
| 640 | it is actually defined. |
---|
| 641 | |
---|
| 642 | >>> from nose.failure import Failure |
---|
| 643 | >>> Failure.__module__ |
---|
| 644 | 'nose.failure' |
---|
| 645 | >>> Nf = transplant_class(Failure, __name__) |
---|
| 646 | >>> Nf.__module__ |
---|
| 647 | 'nose.util' |
---|
| 648 | >>> Nf.__name__ |
---|
| 649 | 'Failure' |
---|
| 650 | |
---|
| 651 | """ |
---|
| 652 | class C(cls): |
---|
| 653 | pass |
---|
| 654 | C.__module__ = module |
---|
| 655 | C.__name__ = cls.__name__ |
---|
| 656 | return C |
---|
| 657 | |
---|
| 658 | |
---|
| 659 | def safe_str(val, encoding='utf-8'): |
---|
| 660 | try: |
---|
| 661 | return str(val) |
---|
| 662 | except UnicodeEncodeError: |
---|
| 663 | if isinstance(val, Exception): |
---|
| 664 | return ' '.join([safe_str(arg, encoding) |
---|
| 665 | for arg in val]) |
---|
| 666 | return unicode(val).encode(encoding) |
---|
| 667 | |
---|
| 668 | |
---|
| 669 | if __name__ == '__main__': |
---|
| 670 | import doctest |
---|
| 671 | doctest.testmod() |
---|