def hashed(cls, clear_password, salt=None): """Hashed value of `clear_password` using `salt`""" if salt is None: salt = bcrypt.gensalt(cls.default_rounds) else: salt = pyk.encoded(salt) result = bcrypt.hashpw(pyk.encoded(clear_password, "ascii"), salt) return pyk.decoded(result, "ascii")
def verify (cls, clear_password, hashed_password) : """True if `clear_password` and `hashed_password` match""" try : cp = pyk.encoded (clear_password, "ascii") hp = pyk.encoded (hashed_password, "ascii") return bcrypt.checkpw (cp, hp) except Exception : return False
def verify(cls, clear_password, hashed_password): """True if `clear_password` and `hashed_password` match""" try: cp = pyk.encoded(clear_password, "ascii") hp = pyk.encoded(hashed_password, "ascii") return bcrypt.checkpw(cp, hp) except Exception: return False
def hashed (cls, clear_password, salt = None) : """Hashed value of `clear_password` using `salt`""" if salt is None : salt = bcrypt.gensalt (cls.default_rounds) else : salt = pyk.encoded (salt) result = bcrypt.hashpw (pyk.encoded (clear_password, "ascii"), salt) return pyk.decoded (result, "ascii")
def _main (cmd) : if cmd.encoding : encoding = cmd.encoding else : encoding = "iso8859-1" if cmd.Print else "utf-8" PMA.default_encoding = encoding for msg in messages_from_args (cmd.argv, cmd.msg_base_dirs) : txt = formatted (msg, encoding = encoding) if cmd.Print : from plumbum import local as pbl from _TFL.FCM import open_tempfile subject = msg.scope.subject pbl.env ["LC_ALL"] = "en_US.%s" % encoding.replace ("-", "") with open_tempfile () as (file, temp_name) : file.write (txt) file.close () a2ps = pbl ["a2ps"] \ [ "-s", "-8", "-nL", "-nu", "-nS" , pyk.encoded ("-H%s" % (subject, ), encoding) , "-P%s" % (cmd.printer_name, ) , temp_name ] if cmd.verbose : print (a2ps) a2ps () else : print (txt)
def b64digest(self, altchars="_-", strip=False): if isinstance(altchars, str): altchars = pyk.encoded(altchars) result = base64.b64encode(self.digest(), altchars) if strip: result = result.rstrip(b"=") return str(result, "ASCII")
def b64digest (self, altchars = "_-", strip = False) : if isinstance (altchars, pyk.text_type) : altchars = pyk.encoded (altchars) result = base64.b64encode (self.digest (), altchars) if strip : result = result.rstrip (b"=") return pyk.text_type (result, "ASCII")
def _handle_pns \ (self, outer, inner, b_name, doc_base) : n_mod, n_pns = self._handle_package_inner (inner, doc_base) scope = Scope \ ( b_name = b_name , m = inner , q_name = "_".join (inner.__name__.split (".")) ) parts = [self._stub_pns_template % scope] doc_path = sos.path.join \ (sos.path.dirname (inner.__file__), "__doc__.py") graph_mod = getattr (inner, "graph", None) if graph_mod is not None : try : self._make_graph (inner, graph_mod, scope.q_name, doc_base) except Exception as exc : logging.exception (doc_path) else : parts [0] += (self._stub_pns_template_graph % scope) if sos.path.isfile (doc_path) : parts [0] += (self._stub_pns_template_doc % scope) if n_mod + n_pns : parts.append (self._stub_pns_template_toc) if n_mod : parts.append (" %s/M_[0-9]*\n" % b_name) if n_pns : parts.append (" %s/P_[0-9]*\n" % b_name) k = inner.__name__.split (".") [-1] s_body = "\n".join (parts) s_name = self._ranked_file_name (outer, k, "P") with self._open_stub (doc_base, outer, s_name) as f : f.write (pyk.encoded (s_body))
def _main(cmd): if cmd.encoding: encoding = cmd.encoding else: encoding = "iso8859-1" if cmd.Print else "utf-8" PMA.default_encoding = encoding for msg in messages_from_args(cmd.argv, cmd.msg_base_dirs): txt = formatted(msg, encoding=encoding) if cmd.Print: from plumbum import local as pbl from _TFL.FCM import open_tempfile subject = msg.scope.subject pbl.env["LC_ALL"] = "en_US.%s" % encoding.replace("-", "") with open_tempfile() as (file, temp_name): file.write(txt) file.close() a2ps = pbl ["a2ps"] \ [ "-s", "-8", "-nL", "-nu", "-nS" , pyk.encoded ("-H%s" % (subject, ), encoding) , "-P%s" % (cmd.printer_name, ) , temp_name ] if cmd.verbose: print(a2ps) a2ps() else: print(txt)
def _stub_mod(self, pns, m, b_name, doc_base): if self.mod_skip_pat.search(m.__name__) or m.__name__ in self.mod_skip: return False x_members = ", ".join(getattr(m, "__sphinx__members", ())) s_body = self._stub_mod_template % Scope(m=m, b_name=b_name, x_members=x_members) s_name = self._ranked_file_name(pns, b_name, "M") with self._open_stub(doc_base, pns, s_name) as f: f.write(pyk.encoded(s_body)) return True
def diff(self, new_content): if self != new_content: old = pyk.text_type(self) new = pyk.decoded(new_content, *self.encodings) diffs = self._diffs \ (old, new, fromfile = self.file_name, tofile = "Result of test") diff_no = len(diffs) d_name = Filename(".diff", self.file_name).name with open(d_name, "wb") as f: f.write(pyk.encoded("\n".join(diffs))) return "%d difference%s (see %s)" % \ (diff_no, "" if diff_no == 1 else "s", d_name)
def diff (self, new_content) : if self != new_content : old = pyk.text_type (self) new = pyk.decoded (new_content, * self.encodings) diffs = self._diffs \ (old, new, fromfile = self.file_name, tofile = "Result of test") diff_no = len (diffs) d_name = Filename (".diff", self.file_name).name with open (d_name, "wb") as f : f.write (pyk.encoded ("\n".join (diffs))) return "%d difference%s (see %s)" % \ (diff_no, "" if diff_no == 1 else "s", d_name)
def __init__(self, request, data, **kw): time = request.current_time b64ed = lambda x : \ pyk.decoded (base64.b64encode (pyk.encoded (x, self.encoding))) self.__dict__.update \ ( cargo = b64ed (data) , data = data , request = request , time = time , timestamp = b64ed (int (time)) , ** kw )
def __init__ (self, request, data, ** kw) : time = request.current_time b64ed = lambda x : \ pyk.decoded (base64.b64encode (pyk.encoded (x, self.encoding))) self.__dict__.update \ ( cargo = b64ed (data) , data = data , request = request , time = time , timestamp = b64ed (int (time)) , ** kw )
def _generate (cao, p, root, tail = None) : name = pjoin (root, tail or p.href_static.lstrip ("/")) dir = sos.path.dirname (name) if not sos.path.exists (dir) : sos.mkdir_p (dir) if cao.verbose : print (name, "...", end = " ") asp = p.as_static_page () if asp is not None : with open (name, "wb") as f : f.write (pyk.encoded (asp)) if cao.verbose : print ("done")
def file_info (self, file_name) : stat_result = os.stat (file_name) mtime = stat_result [stat.ST_MTIME] size = stat_result [stat.ST_SIZE] last_modified = datetime.fromtimestamp (mtime) offset = TFL.user_config.time_zone.utcoffset (last_modified) last_modified -= offset fn_hash = zlib.adler32 (pyk.encoded (file_name)) & 0xffffffff return TFL.Record \ ( etag = "sf-%s-%s-%s" % (mtime, size, fn_hash) , last_modified = last_modified , content_length = size )
def _stub_mod (self, pns, m, b_name, doc_base) : if self.mod_skip_pat.search (m.__name__) or m.__name__ in self.mod_skip: return False x_members = ", ".join (getattr (m, "__sphinx__members", ())) s_body = self._stub_mod_template % Scope \ ( m = m , b_name = b_name , x_members = x_members ) s_name = self._ranked_file_name (pns, b_name, "M") with self._open_stub (doc_base, pns, s_name) as f : f.write (pyk.encoded (s_body)) return True
def kassabuch (account, file) : """Write entries in `account' to kassabuch `file'""" for e in account.entries : if not isinstance (e, Account_Entry) : continue e.desc = par_sub_pat.sub ("[\\1]", e.desc) if "-" in e.dir : file.write \ ( pyk.encoded ( "\\A %6s %-50s (%8s) [%s]\n" % (e.date, e.desc, e.gross.as_string (), e.number) ) ) elif "+" in e.dir : print ("Income entries not yet implemented", e)
def kassabuch(account, file): """Write entries in `account` to kassabuch `file`""" for e in account.entries: if not isinstance(e, Account_Entry): continue e.desc = par_sub_pat.sub("[\\1]", e.desc) if "-" in e.dir: file.write \ ( pyk.encoded ( "\\A %6s %-50s (%8s) [%s]\n" % (e.date, e.desc, e.gross.as_string (), e.number) ) ) elif "+" in e.dir: print("Income entries not yet implemented", e)
def is_non_ascii(x): """Return true if byte-string `x` contains non-ascii characters. >>> is_non_ascii ("abc") False >>> is_non_ascii ("äbc") True """ y = pyk.encoded(x, "utf-8") try: y.decode("ascii") except UnicodeDecodeError: return True else: return False
def _main(cmd): """For each argument, write sanitized_filename to stdout. If `-rename` is specified, the files are renamed to the sanitized_filenames instead. """ from _TFL import sos from _TFL.pyk import pyk for f_b in cmd.argv: f = pyk.decoded(f_b) sf = sanitized_filename(f) sf_b = pyk.encoded(sf) if cmd.rename: if f_b != sf_b and sos.path.exists(f_b): sos.rename(f_b, sf_b) if cmd.verbose: print("Renamed", f, "to", sf) else: print(sf, end=cmd.separator)
def _main (cmd) : """For each argument, write sanitized_filename to stdout. If `-rename` is specified, the files are renamed to the sanitized_filenames instead. """ from _TFL import sos from _TFL.pyk import pyk for f_b in cmd.argv : f = pyk.decoded (f_b) sf = sanitized_filename (f) sf_b = pyk.encoded (sf) if cmd.rename : if f_b != sf_b and sos.path.exists (f_b) : sos.rename (f_b, sf_b) if cmd.verbose : pyk.fprint ("Renamed", f, "to", sf) else : pyk.fprint (sf, end = cmd.separator)
def is_non_ascii (x) : """Return true if byte-string `x` contains non-ascii characters. >>> is_non_ascii ("abc") False >>> is_non_ascii ("äbc") True """ y = pyk.encoded (x, "utf-8") try : y.decode ("ascii") except UnicodeDecodeError : return True else : return False
def _handler (self, sub, cmd) : time_format = _Sub_Command_.time_fmt = cmd.time_format i_enc = cmd.input_encoding o_enc = cmd.output_encoding pbl.env ["LC_ALL"] = "en_US.%s" % o_enc.replace ("-", "") for arg in cmd.argv : if arg in ("-", "STDIN") : file_time = time.localtime () fn = "STDIN" txt_in = sys.stdin.read () else : file_time = time.localtime (sos.path.getmtime (arg)) fn = Filename (arg).relative_to ("~/") with open (arg, "rb") as fi : txt_in = fi.read () txt = txt_in.decode (i_enc) ft = time.strftime (time_format, file_time) txt_out = txt.encode (o_enc, "replace") options = tuple \ (pyk.encoded (o) for o in sub.options (cmd, fn, ft)) pbl_cmd = sub.pbl_cmd.__getitem__ (options) with open_tempfile () as (fo, no) : fo.write (txt_out) fo.close () cx = pbl_cmd [no] if cmd.verbose or cmd.dry_run : print (pbl_cmd, arg, "[%s]" % no) if not cmd.dry_run : if cmd.Display : if cmd.Print : print \ ( "Specify either -Display or -Print, " "but not both" ) raise SystemExit (10) with open_tempfile () as (fd, nd) : fd.write (cx ()) fd.close () pbl [cmd.display_program] [nd] () else : cx ()
def _handler(self, sub, cmd): time_format = _Sub_Command_.time_fmt = cmd.time_format i_enc = cmd.input_encoding o_enc = cmd.output_encoding pbl.env["LC_ALL"] = "en_US.%s" % o_enc.replace("-", "") for arg in cmd.argv: if arg in ("-", "STDIN"): file_time = time.localtime() fn = "STDIN" txt_in = sys.stdin.read() else: file_time = time.localtime(sos.path.getmtime(arg)) fn = Filename(arg).relative_to("~/") with open(arg, "rb") as fi: txt_in = fi.read() txt = txt_in.decode(i_enc).lstrip("\n").rstrip() ft = time.strftime(time_format, file_time) txt_out = self._encoded(txt, o_enc) options = tuple \ (pyk.encoded (o) for o in sub.options (cmd, fn, ft)) pbl_cmd = sub.pbl_cmd.__getitem__(options) with open_tempfile() as (fo, no): fo.write(txt_out) fo.close() cx = pbl_cmd[no] if cmd.verbose or cmd.dry_run: print(pbl_cmd, arg, "[%s]" % no) if not cmd.dry_run: if cmd.Display: if cmd.Print: print \ ( "Specify either -Display or -Print, " "but not both" ) raise SystemExit(10) with open_tempfile() as (fd, nd): fd.write(cx()) fd.close() pbl[cmd.display_program][nd]() else: cx()
def _create_config_uwsgi (self, cao, config_options, templateer) : P = self._P (cao) app_dir = sos.path.dirname (self._app_path (cao, P)) macro = templateer.GTW.get_macro \ ("uwsgi_config_ini", templ_name = config_options ["templ_name"]) script_name = Filename (".ini", cao.script_path, absolute = True) c_path = script_name.name \ if script_name.base not in ("-", "stdout") else "" socket = config_options ["socket"] if socket.startswith ("unix:") : socket = socket [5:] stats_server = config_options ["stats_server"] if stats_server.startswith ("unix:") : stats_server = stats_server [5:] kw = dict \ ( chdir = script_name.directory , chmod_socket = "660" , chown_socket = "%s:%s" % (cao.user or cao.http_user, cao.http_user) , config_name = c_path , gid = cao.group or cao.http_user , lazy_apps = ["false", "true"] [cao.lazy_apps] , master = "true" , module = script_name.base , need_threads = "true" , processes = cao.processes , py_path = reversed ([pyk.encoded (app_dir)] + P.py_path.split (":")) , server_name = config_options ["server_name"] , socket = socket , stats_server = stats_server , threads = 0 , uid = cao.user or cao.http_user , virtualenv = cao.virtualenv ) config = macro (** kw) config_s = strip_empty_lines (config) self._write_config \ (cao, c_path, config_s, "Created uwsgi config")
def _create_wsgi_script \ (self, cao, argv = (), script_path = None, script_format = None) : P = self._P (cao) a_conf = cao.app_config try : h_conf = cao._spec ["HTTP_Config"].pathes except KeyError : h_conf = [] config = self.App_Config.auto_split.join (a_conf) app_dir = sos.path.dirname (self._app_path (cao, P)) app_mod = sos.path.splitext (sos.path.basename (cao.app_module)) [0] args = ("wsgi", "-config", config) + tuple (argv) s_path = script_path or cao.script_path if script_format is None : script_format = self._wsgi_script_format script = script_format % dict \ ( app_dir = app_dir , app_mod = app_mod , args = list (args) if args else "" , py_path = [pyk.encoded (app_dir)] + P.py_path.split (":") , server_name = cao.server_name ) self._write_config (cao, s_path, script, "Created wsgi script")
def save(filename, body): if body: with open(filename, "wb") as f: f.write(pyk.encoded(body, PMA.default_encoding))
def safe_str_cmp (lhs, rhs) : l = pyk.encoded (lhs, "iso-8859-1") r = pyk.encoded (rhs, "iso-8859-1") return _wz_safe_str_cmp (l, r)
def __eq__ (self, other) : return self.encoded == pyk.encoded (other)
def _encoded (cls, obj) : return pyk.encoded (portable_repr (obj).strip (""""'"""), "utf-8")
def save (filename, body) : if body : with open (filename, "wb") as f : f.write (pyk.encoded (body, PMA.default_encoding))
def _encoded(cls, obj): return pyk.encoded(portable_repr(obj).strip(""""'"""), "utf-8")
def __lt__ (self, other) : return self.encoded < pyk.encoded (other)
def __call__ (self, text, mail_opts = (), rcpt_opts = None) : email = pyk.email_message_from_bytes (pyk.encoded (text, self.charset)) self.send_message (email, mail_opts = mail_opts, rcpt_opts = rcpt_opts)
def send (self, from_addr, to_addrs, msg, mail_opts = (), rcpt_opts = None) : with self.connection () as server : msg_x = pyk.encoded (msg, self.charset) server.sendmail (from_addr, to_addrs, msg_x, mail_opts, rcpt_opts)
def __le__ (self, other) : return self.encoded <= pyk.encoded (other)
def unpickle_time (pv) : return datetime.time (pyk.encoded (pv, "latin1"))
def encoded (self) : return pyk.encoded (self.as_text)
def _new (self, mt, st, b) : msg = pyk.email_message_from_bytes (pyk.encoded (b, "latin-1")) return self.MIME (msg, _subtype = st)
def unpickle_time(pv): return datetime.time(pyk.encoded(pv, "latin1"))
def _new(self, mt, st, b): msg = pyk.email_message_from_bytes(pyk.encoded(b, "latin-1")) return self.MIME(msg, _subtype=st)
def safe_str_cmp(lhs, rhs): l = pyk.encoded(lhs, "iso-8859-1") r = pyk.encoded(rhs, "iso-8859-1") return _wz_safe_str_cmp(l, r)