我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tornado.version()。
def set_secure_cookie(self, name, value, expires_days=30, version=None, **kwargs): """Signs and timestamps a cookie so it cannot be forged. You must specify the ``cookie_secret`` setting in your Application to use this method. It should be a long, random sequence of bytes to be used as the HMAC secret for the signature. To read a cookie set with this method, use `get_secure_cookie()`. Note that the ``expires_days`` parameter sets the lifetime of the cookie in the browser, but is independent of the ``max_age_days`` parameter to `get_secure_cookie`. Secure cookies may contain arbitrary byte values, not just unicode strings (unlike regular cookies) .. versionchanged:: 3.2.1 Added the ``version`` argument. Introduced cookie version 2 and made it the default. """ self.set_cookie(name, self.create_signed_value(name, value, version=version), expires_days=expires_days, **kwargs)
def create_signed_value(self, name, value, version=None): """Signs and timestamps a string so it cannot be forged. Normally used via set_secure_cookie, but provided as a separate method for non-cookie uses. To decode a value not stored as a cookie use the optional value argument to get_secure_cookie. .. versionchanged:: 3.2.1 Added the ``version`` argument. Introduced cookie version 2 and made it the default. """ self.require_setting("cookie_secret", "secure cookies") secret = self.application.settings["cookie_secret"] key_version = None if isinstance(secret, dict): if self.application.settings.get("key_version") is None: raise Exception("key_version setting must be used for secret_key dicts") key_version = self.application.settings["key_version"] return create_signed_value(secret, name, value, version=version, key_version=key_version)
def _get_raw_xsrf_token(self): """Read or generate the xsrf token in its raw form. The raw_xsrf_token is a tuple containing: * version: the version of the cookie from which this token was read, or None if we generated a new token in this request. * token: the raw token data; random (non-ascii) bytes. * timestamp: the time this token was generated (will not be accurate for version 1 cookies) """ if not hasattr(self, '_raw_xsrf_token'): cookie = self.get_cookie("_xsrf") if cookie: version, token, timestamp = self._decode_xsrf_token(cookie) else: version, token, timestamp = None, None, None if token is None: version = None token = os.urandom(16) timestamp = time.time() self._raw_xsrf_token = (version, token, timestamp) return self._raw_xsrf_token
def get_content_version(cls, abspath): """Returns a version string for the resource at the given path. This class method may be overridden by subclasses. The default implementation is a hash of the file's contents. .. versionadded:: 3.1 """ data = cls.get_content(abspath) hasher = hashlib.md5() if isinstance(data, bytes): hasher.update(data) else: for chunk in data: hasher.update(chunk) return hasher.hexdigest()
def _get_version(value): # Figures out what version value is. Version 1 did not include an # explicit version field and started with arbitrary base64 data, # which makes this tricky. m = _signed_value_version_re.match(value) if m is None: version = 1 else: try: version = int(m.group(1)) if version > 999: # Certain payloads from the version-less v1 format may # be parsed as valid integers. Due to base64 padding # restrictions, this can only happen for numbers whose # length is a multiple of 4, so we can treat all # numbers up to 999 as versions, and for the rest we # fall back to v1 format. version = 1 except ValueError: version = 1 return version
def _decode_fields_v2(value): def _consume_field(s): length, _, rest = s.partition(b':') n = int(length) field_value = rest[:n] # In python 3, indexing bytes returns small integers; we must # use a slice to get a byte string as in python 2. if rest[n:n + 1] != b'|': raise ValueError("malformed v2 signed value field") rest = rest[n + 1:] return field_value, rest rest = value[2:] # remove version number key_version, rest = _consume_field(rest) timestamp, rest = _consume_field(rest) name_field, rest = _consume_field(rest) value_field, passed_sig = _consume_field(rest) return int(key_version), timestamp, name_field, value_field, passed_sig
def get_secure_cookie(self, name, value=None, max_age_days=31, min_version=None): """Returns the given signed cookie if it validates, or None. The decoded cookie value is returned as a byte string (unlike `get_cookie`). .. versionchanged:: 3.2.1 Added the ``min_version`` argument. Introduced cookie version 2; both versions 1 and 2 are accepted by default. """ self.require_setting("cookie_secret", "secure cookies") if value is None: value = self.get_cookie(name) return decode_signed_value(self.application.settings["cookie_secret"], name, value, max_age_days=max_age_days, min_version=min_version)
def decode_signed_value(secret, name, value, max_age_days=31, clock=None, min_version=None): if clock is None: clock = time.time if min_version is None: min_version = DEFAULT_SIGNED_VALUE_MIN_VERSION if min_version > 2: raise ValueError("Unsupported min_version %d" % min_version) if not value: return None value = utf8(value) version = _get_version(value) if version < min_version: return None if version == 1: return _decode_signed_value_v1(secret, name, value, max_age_days, clock) elif version == 2: return _decode_signed_value_v2(secret, name, value, max_age_days, clock) else: return None
def check(self): if sys.platform == 'win32': check_include_file(get_include_dirs(), 'ft2build.h', 'freetype') return 'Using unknown version found on system.' status, output = getstatusoutput("freetype-config --ftversion") if status == 0: version = output else: version = None # Early versions of freetype grep badly inside freetype-config, # so catch those cases. (tested with 2.5.3). if version is None or 'No such file or directory\ngrep:' in version: version = self.version_from_header() # pkg_config returns the libtool version rather than the # freetype version so we need to explicitly pass the version # to _check_for_pkg_config return self._check_for_pkg_config( 'freetype2', 'ft2build.h', min_version='2.3', version=version)
def version_from_header(self): version = 'unknown' ext = self.get_extension() if ext is None: return version # Return the first version found in the include dirs. for include_dir in ext.include_dirs: header_fname = os.path.join(include_dir, 'freetype.h') if os.path.exists(header_fname): major, minor, patch = 0, 0, 0 with open(header_fname, 'r') as fh: for line in fh: if line.startswith('#define FREETYPE_'): value = line.rsplit(' ', 1)[1].strip() if 'MAJOR' in line: major = value elif 'MINOR' in line: minor = value else: patch = value return '.'.join([major, minor, patch])
def check(self): if sys.platform == 'win32': check_include_file(get_include_dirs(), 'png.h', 'png') return 'Using unknown version found on system.' status, output = getstatusoutput("libpng-config --version") if status == 0: version = output else: version = None try: return self._check_for_pkg_config( 'libpng', 'png.h', min_version='1.2', version=version) except CheckFailed as e: if has_include_file(get_include_dirs(), 'png.h'): return str(e) + ' Using unknown version found on system.' raise
def check(self): self.__class__.found_external = True try: return self._check_for_pkg_config( 'qhull', 'qhull/qhull_a.h', min_version='2003.1') except CheckFailed as e: self.__class__.found_pkgconfig = False # Qhull may not be in the pkg-config system but may still be # present on this system, so check if the header files can be # found. include_dirs = [ os.path.join(x, 'qhull') for x in get_include_dirs()] if has_include_file(include_dirs, 'qhull_a.h'): return 'Using system Qhull (version unknown, no pkg-config info)' else: self.__class__.found_external = False return str(e) + ' Using local copy.'
def check(self): try: import dateutil except ImportError: # dateutil 2.1 has a file encoding bug that breaks installation on # python 3.3 # https://github.com/matplotlib/matplotlib/issues/2373 # hack around the problem by installing the (working) v2.0 #major, minor1, _, _, _ = sys.version_info #if self.version is None and (major, minor1) == (3, 3): #self.version = '!=2.1' raise CheckFailed ( "could not be found") major, minor1, _, _, _ = sys.version_info if dateutil.__version__ == '2.1' and (major, minor1) == (3, 3): raise CheckFailed ( "dateutil v. 2.1 has a bug that breaks installation" "on python 3.3.x, use another dateutil version") return "using dateutil version %s" % dateutil.__version__
def check(self): try: import pyparsing except ImportError: raise CheckFailed( "could not be found") required = [1, 5, 6] if [int(x) for x in pyparsing.__version__.split('.')] < required: raise CheckFailed( "matplotlib requires pyparsing >= {0}".format( '.'.join(str(x) for x in required))) if not self.is_ok(): return ( "Your pyparsing contains a bug that will be monkey-patched by " "matplotlib. For best results, upgrade to pyparsing 2.0.1 or " "later.") return "using pyparsing version %s" % pyparsing.__version__
def backend_gtk3agg_internal_check(x): try: import gi except ImportError: return (False, "Requires pygobject to be installed.") try: gi.require_version("Gtk", "3.0") except ValueError: return (False, "Requires gtk3 development files to be installed.") except AttributeError: return (False, "pygobject version too old.") try: from gi.repository import Gtk, Gdk, GObject except (ImportError, RuntimeError): return (False, "Requires pygobject to be installed.") return (True, "version %s.%s.%s" % ( Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version()))
def check(self): try: if sys.platform == 'win32': command = 'gswin32c --version' try: output = check_output(command, shell=True, stderr=subprocess.STDOUT) except subprocess.CalledProcessError: command = 'gswin64c --version' output = check_output(command, shell=True, stderr=subprocess.STDOUT) else: command = 'gs --version' output = check_output(command, shell=True, stderr=subprocess.STDOUT) return "version %s" % output.decode()[:-1] except (IndexError, ValueError, subprocess.CalledProcessError): raise CheckFailed()
def clear(self): """Resets all headers and content for this response.""" # The performance cost of tornado.httputil.HTTPHeaders is significant # (slowing down a benchmark with a trivial handler by more than 10%), # and its case-normalization is not generally necessary for # headers we generate on the server side, so use a plain dict # and list instead. self._headers = { "Server": "TornadoServer/%s" % tornado.version, "Content-Type": "text/html; charset=UTF-8", } self._list_headers = [] self.set_default_headers() if not self.request.supports_http_1_1(): if self.request.headers.get("Connection") == "Keep-Alive": self.set_header("Connection", "Keep-Alive") self._write_buffer = [] self._status_code = 200
def clear(self): """Resets all headers and content for this response.""" self._headers = httputil.HTTPHeaders({ "Server": "TornadoServer/%s" % tornado.version, "Content-Type": "text/html; charset=UTF-8", "Date": httputil.format_timestamp(time.time()), }) self.set_default_headers() if (not self.request.supports_http_1_1() and getattr(self.request, 'connection', None) and not self.request.connection.no_keep_alive): conn_header = self.request.headers.get("Connection") if conn_header and (conn_header.lower() == "keep-alive"): self._headers["Connection"] = "Keep-Alive" self._write_buffer = [] self._status_code = 200 self._reason = httputil.responses[200]
def get_content_version(cls, abspath): """Returns a version string for the resource at the given path. This class method may be overridden by subclasses. The default implementation is a hash of the file's contents. .. versionadded:: 3.1 """ data = cls.get_content(abspath) hasher = hashlib.md5() if isinstance(data, bytes_type): hasher.update(data) else: for chunk in data: hasher.update(chunk) return hasher.hexdigest()
