__init__.py (9658B)
1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\lib\cherrypy\__init__.py 2 __version__ = '3.2.0' 3 from cherrypy._cpcompat import urljoin as _urljoin, urlencode as _urlencode 4 from cherrypy._cpcompat import basestring, unicodestr 5 from cherrypy._cperror import HTTPError, HTTPRedirect, InternalRedirect 6 from cherrypy._cperror import NotFound, CherryPyException, TimeoutError 7 from cherrypy import _cpdispatch as dispatch 8 from cherrypy import _cptools 9 tools = _cptools.default_toolbox 10 Tool = _cptools.Tool 11 from cherrypy import _cprequest 12 from cherrypy.lib import httputil as _httputil 13 from cherrypy import _cptree 14 tree = _cptree.Tree() 15 from cherrypy._cptree import Application 16 from cherrypy import _cpwsgi as wsgi 17 from cherrypy import process 18 try: 19 from cherrypy.process import win32 20 engine = win32.Win32Bus() 21 engine.console_control_handler = win32.ConsoleCtrlHandler(engine) 22 del win32 23 except ImportError: 24 engine = process.bus 25 26 class _TimeoutMonitor(process.plugins.Monitor): 27 28 def __init__(self, bus): 29 self.servings = [] 30 process.plugins.Monitor.__init__(self, bus, self.run) 31 32 def acquire(self): 33 self.servings.append((serving.request, serving.response)) 34 35 def release(self): 36 try: 37 self.servings.remove((serving.request, serving.response)) 38 except ValueError: 39 pass 40 41 def run(self): 42 for req, resp in self.servings: 43 resp.check_timeout() 44 45 46 engine.timeout_monitor = _TimeoutMonitor(engine) 47 engine.timeout_monitor.subscribe() 48 engine.autoreload = process.plugins.Autoreloader(engine) 49 engine.autoreload.subscribe() 50 engine.thread_manager = process.plugins.ThreadManager(engine) 51 engine.thread_manager.subscribe() 52 engine.signal_handler = process.plugins.SignalHandler(engine) 53 from cherrypy import _cpserver 54 server = _cpserver.Server() 55 server.subscribe() 56 57 def quickstart(root = None, script_name = '', config = None): 58 if config: 59 _global_conf_alias.update(config) 60 tree.mount(root, script_name, config) 61 if hasattr(engine, 'signal_handler'): 62 engine.signal_handler.subscribe() 63 if hasattr(engine, 'console_control_handler'): 64 engine.console_control_handler.subscribe() 65 engine.start() 66 engine.block() 67 68 69 from cherrypy._cpcompat import threadlocal as _local 70 71 class _Serving(_local): 72 request = _cprequest.Request(_httputil.Host('127.0.0.1', 80), _httputil.Host('127.0.0.1', 1111)) 73 response = _cprequest.Response() 74 75 def load(self, request, response): 76 self.request = request 77 self.response = response 78 79 def clear(self): 80 self.__dict__.clear() 81 82 83 serving = _Serving() 84 85 class _ThreadLocalProxy(object): 86 __slots__ = ['__attrname__', '__dict__'] 87 88 def __init__(self, attrname): 89 self.__attrname__ = attrname 90 91 def __getattr__(self, name): 92 child = getattr(serving, self.__attrname__) 93 return getattr(child, name) 94 95 def __setattr__(self, name, value): 96 if name in ('__attrname__',): 97 object.__setattr__(self, name, value) 98 else: 99 child = getattr(serving, self.__attrname__) 100 setattr(child, name, value) 101 102 def __delattr__(self, name): 103 child = getattr(serving, self.__attrname__) 104 delattr(child, name) 105 106 def _get_dict(self): 107 child = getattr(serving, self.__attrname__) 108 d = child.__class__.__dict__.copy() 109 d.update(child.__dict__) 110 return d 111 112 __dict__ = property(_get_dict) 113 114 def __getitem__(self, key): 115 child = getattr(serving, self.__attrname__) 116 return child[key] 117 118 def __setitem__(self, key, value): 119 child = getattr(serving, self.__attrname__) 120 child[key] = value 121 122 def __delitem__(self, key): 123 child = getattr(serving, self.__attrname__) 124 del child[key] 125 126 def __contains__(self, key): 127 child = getattr(serving, self.__attrname__) 128 return key in child 129 130 def __len__(self): 131 child = getattr(serving, self.__attrname__) 132 return len(child) 133 134 def __nonzero__(self): 135 child = getattr(serving, self.__attrname__) 136 return bool(child) 137 138 __bool__ = __nonzero__ 139 140 141 request = _ThreadLocalProxy('request') 142 response = _ThreadLocalProxy('response') 143 144 class _ThreadData(_local): 145 pass 146 147 148 thread_data = _ThreadData() 149 150 def _cherrypy_pydoc_resolve(thing, forceload = 0): 151 if isinstance(thing, _ThreadLocalProxy): 152 thing = getattr(serving, thing.__attrname__) 153 return _pydoc._builtin_resolve(thing, forceload) 154 155 156 try: 157 import pydoc as _pydoc 158 _pydoc._builtin_resolve = _pydoc.resolve 159 _pydoc.resolve = _cherrypy_pydoc_resolve 160 except ImportError: 161 pass 162 163 from cherrypy import _cplogging 164 165 class _GlobalLogManager(_cplogging.LogManager): 166 167 def __call__(self, *args, **kwargs): 168 if hasattr(request, 'app') and hasattr(request.app, 'log'): 169 log = request.app.log 170 else: 171 log = self 172 return log.error(*args, **kwargs) 173 174 def access(self): 175 try: 176 return request.app.log.access() 177 except AttributeError: 178 return _cplogging.LogManager.access(self) 179 180 181 log = _GlobalLogManager() 182 log.screen = True 183 log.error_file = '' 184 log.access_file = '' 185 186 def _buslog(msg, level): 187 log.error(msg, 'ENGINE', severity=level) 188 189 190 engine.subscribe('log', _buslog) 191 192 def expose(func = None, alias = None): 193 194 def expose_(func): 195 func.exposed = True 196 if alias is not None: 197 if isinstance(alias, basestring): 198 parents[alias.replace('.', '_')] = func 199 else: 200 for a in alias: 201 parents[a.replace('.', '_')] = func 202 203 return func 204 205 import sys, types 206 if isinstance(func, (types.FunctionType, types.MethodType)): 207 if alias is None: 208 func.exposed = True 209 return func 210 else: 211 parents = sys._getframe(1).f_locals 212 return expose_(func) 213 elif func is None: 214 if alias is None: 215 parents = sys._getframe(1).f_locals 216 return expose_ 217 else: 218 parents = sys._getframe(1).f_locals 219 return expose_ 220 else: 221 parents = sys._getframe(1).f_locals 222 alias = func 223 return expose_ 224 225 226 def popargs(*args, **kwargs): 227 handler = None 228 handler_call = False 229 for k, v in kwargs.items(): 230 if k == 'handler': 231 handler = v 232 else: 233 raise TypeError("cherrypy.popargs() got an unexpected keyword argument '{0}'".format(k)) 234 235 import inspect 236 if handler is not None and (hasattr(handler, '__call__') or inspect.isclass(handler)): 237 handler_call = True 238 239 def decorated(cls_or_self = None, vpath = None): 240 if inspect.isclass(cls_or_self): 241 cls = cls_or_self 242 setattr(cls, dispatch.Dispatcher.dispatch_method_name, decorated) 243 return cls 244 self = cls_or_self 245 parms = {} 246 for arg in args: 247 if not vpath: 248 break 249 parms[arg] = vpath.pop(0) 250 251 if handler is not None: 252 if handler_call: 253 return handler(**parms) 254 else: 255 request.params.update(parms) 256 return handler 257 request.params.update(parms) 258 if vpath: 259 return getattr(self, vpath.pop(0), None) 260 else: 261 return self 262 263 return decorated 264 265 266 def url(path = '', qs = '', script_name = None, base = None, relative = None): 267 if isinstance(qs, (tuple, list, dict)): 268 qs = _urlencode(qs) 269 if qs: 270 qs = '?' + qs 271 if request.app: 272 if not path.startswith('/'): 273 pi = request.path_info 274 if request.is_index is True: 275 if not pi.endswith('/'): 276 pi = pi + '/' 277 elif request.is_index is False: 278 if pi.endswith('/') and pi != '/': 279 pi = pi[:-1] 280 if path == '': 281 path = pi 282 else: 283 path = _urljoin(pi, path) 284 if script_name is None: 285 script_name = request.script_name 286 if base is None: 287 base = request.base 288 newurl = base + script_name + path + qs 289 else: 290 if base is None: 291 base = server.base() 292 path = (script_name or '') + path 293 newurl = base + path + qs 294 if './' in newurl: 295 atoms = [] 296 for atom in newurl.split('/'): 297 if atom == '.': 298 pass 299 elif atom == '..': 300 atoms.pop() 301 else: 302 atoms.append(atom) 303 304 newurl = '/'.join(atoms) 305 if relative is None: 306 relative = getattr(request.app, 'relative_urls', False) 307 if relative == 'server': 308 newurl = '/' + '/'.join(newurl.split('/', 3)[3:]) 309 elif relative: 310 old = url().split('/')[:-1] 311 new = newurl.split('/') 312 while old and new: 313 a, b = old[0], new[0] 314 if a != b: 315 break 316 old.pop(0) 317 new.pop(0) 318 319 new = ['..'] * len(old) + new 320 newurl = '/'.join(new) 321 return newurl 322 323 324 from cherrypy import _cpconfig 325 config = _global_conf_alias = _cpconfig.Config() 326 config.defaults = {'tools.log_tracebacks.on': True, 327 'tools.log_headers.on': True, 328 'tools.trailing_slash.on': True, 329 'tools.encode.on': True} 330 config.namespaces['log'] = lambda k, v: setattr(log, k, v) 331 config.namespaces['checker'] = lambda k, v: setattr(checker, k, v) 332 config.reset() 333 from cherrypy import _cpchecker 334 checker = _cpchecker.Checker() 335 engine.subscribe('start', checker)