def task(): model = loader.loadModel(abspath(f"models/{mod}_low_flat.bam")) model.clearModelNodes() model.flattenStrong() model.setHpr(orient*90+180, 90, 0) model.reparentTo(parent) model.setPos(Vec3(pos)+Vec3(10, 10, 0)) model.setScale(10.0)
def set_tower(self, loader, tower_class): self.remove_tower() self.tower = loader.loadModel( abspath(f"models/{tower_class.name}.dae")) self.tower.reparentTo(self.model) self.tower.setHpr(0, 90, 0) self.tower.setTransparency(TransparencyAttrib.MAlpha) self.tower.setAlphaScale(0.5) self.tower.setScale(tower_class.scale) self.tower_class = tower_class
def generate(self, loader, parent, get_tile): """Load in the model into self.model.""" self.model = loader.loadModel(abspath(f"models/{self.name}.dae")) self.model.clearModelNodes() self.model.flattenStrong() self.model.reparentTo(parent) self.model.setHpr(self.hpr) self.model.setScale(self.scale) self.model.setPos(self.pos) self.active = True self.generated = True self.get_tile = get_tile del self.pos del self.hpr
def create_file_tree(rootdir): """Creates a k-tree that takes the dir hierarchy and parent-child relationships and turns it into package-module and package - sub-package relationship. Arguments: rootdir:- path to rootdir of project being analyzed. Returns: The file tree """ if not os.path.isdir(rootdir): error("root is not a dir") root = tree.FileTree(rootdir) pathmap = {} ptr = None this = None for selfpath, dirs, files in os.walk(rootdir): #selfpath is own path #dirs is child dirs #files is child files this = pathmap.get(selfpath, root) for d in dirs: path = ut.abspath(selfpath, d) ptr = this.add_child_dir(path) pathmap[path] = ptr for f in files: path = ut.abspath(selfpath, f) ptr = this.add_child_file(path) pathmap[path] = ptr if f == "__init__.py": this.set_package(True) #print root return root
def tid2ts(tmx, id, basefile): "for a given tid in tmx, find the tileset + local tid type" for ts in tmx.findall('tileset'): if int(ts.get('firstgid')) > id: break last_ts = ts rid = id - int(last_ts.get('firstgid')) # local id of this tile within src = last_ts.get('source') if src: ts = ET.parse(abspath(basefile, src)).getroot() else: ts = last_ts return ts, rid
def getData(self,including_deps = True): data = {} if C('disable_deps_search') or not including_deps: deps = [self.__token+'.'+C('template_ext')] else: #复制 deps = self.__deps[0:] deps.reverse() deps.insert(len(deps),self.__token+".json") deps.insert(0,"_ursa.json") for dep in deps: try: json_filepath = utils.abspath(os.path.join(C('data_dir'),re.sub(r'\.%s$'%C('template_ext'),'.json',dep))) content = utils.readfile(json_filepath) content = re.sub('\/\*[\s\S]*?\*\/','',content) json_data = json.loads(content) data.update(json_data) except Exception, e: e#log.warn('[getdata]%s:%s'%(json_filepath,e))
def _search(self,tpl): ''' 递归搜索 ''' try: abspath = utils.abspath(os.path.join(C('template_dir'),tpl)) content = utils.readfile(abspath) iters = re.finditer(self._pattern,content) for i in reversed(list(iters)): tpl = utils.filterRelPath(i.group(3)) if C('ignore_parents') and tpl.endswith('parent.'+C('template_ext')): continue if self._history.get(tpl) is None: self._result.append(tpl) self._history[tpl] = 1 if 'include' == i.group(1): self._include_result.append(tpl) self._search(tpl) except Exception, e: log.error('[deps]%s'%e)
"Python file defining a list H of homographies to be used in uNetXST model" ) parser.add("-mw", "--model-weights", type=str, required=True, help="weights file of trained model") parser.add("-pd", "--prediction-dir", type=str, required=True, help="output directory for storing predictions of testing data") conf, unknown = parser.parse_known_args() # determine absolute filepaths conf.input_testing = [utils.abspath(path) for path in conf.input_testing] conf.one_hot_palette_input = utils.abspath(conf.one_hot_palette_input) conf.one_hot_palette_label = utils.abspath(conf.one_hot_palette_label) conf.model = utils.abspath(conf.model) conf.unetxst_homographies = utils.abspath( conf.unetxst_homographies ) if conf.unetxst_homographies is not None else conf.unetxst_homographies conf.model_weights = utils.abspath(conf.model_weights) conf.prediction_dir = utils.abspath(conf.prediction_dir) # load network architecture module architecture = utils.load_module(conf.model) # get max_samples_testing samples files_input = [ utils.get_files_in_folder(folder) for folder in conf.input_testing
#!/usr/bin/env python3 # Generates a fizzbuzz, with some mistakes import utils MAX = 1000 OUTPUT = "fizzbuzz" FORMAT = "{}\t{}\n" def writeout(output, num, msg): output.write(FORMAT.format(num, msg)) with open(utils.abspath(OUTPUT), mode = "w") as output: for num in range(MAX + 1): three = (num % 3) == 0 five = (num % 5) == 0 if num == 28: writeout(output, num, "Woof!") continue if num == 25: writeout(output, num, "Fizz") continue if num == 30: writeout(output, num, "Buzz") continue if three and five: writeout(output, num, "FizzBuzz") elif three: writeout(output, num, "Fizz")
def __init__(self): super(PathFinder, self).__init__() basedir, filename = utils.split(utils.abspath(__file__)) self.config_name = os.path.join(basedir, "workspace_path_config.json") self.logger = logging.getLogger("main_log.path_finder") self.path_dict = self.read_in_path_config(self.config_name)
import os import shutil import tempfile import time import utils from nova import vendor import M2Crypto from nova import exception from nova import flags FLAGS = flags.FLAGS flags.DEFINE_string('ca_file', 'cacert.pem', 'Filename of root CA') flags.DEFINE_string('keys_path', utils.abspath('../keys'), 'Where we keep our keys') flags.DEFINE_string('ca_path', utils.abspath('../CA'), 'Where we keep our root CA') flags.DEFINE_boolean('use_intermediate_ca', False, 'Should we use intermediate CAs for each project?') def ca_path(project_id): if project_id: return "%s/INTER/%s/cacert.pem" % (FLAGS.ca_path, project_id) return "%s/cacert.pem" % (FLAGS.ca_path) def fetch_ca(project_id=None, chain=True): if not FLAGS.use_intermediate_ca: project_id = None buffer = "" if project_id: with open(ca_path(project_id),"r") as cafile: buffer += cafile.read()
import sys import threading from utils import abspath import Tkinter as tk def remove_values_from_list(the_list, val): return [value for value in the_list if value != val] _LIB_DIR = '../lib/' _LIB32_DIR = '../lib32/' _LIB64_DIR = '../lib64/' if sys.maxsize > 2**32: print 'using 64bit libs' _plat_lib_path = abspath(_LIB64_DIR) sys.path = remove_values_from_list(sys.path, abspath(_LIB32_DIR)) else: print 'using 32bit libs' _plat_lib_path = abspath(_LIB32_DIR) sys.path = remove_values_from_list(sys.path, abspath(_LIB64_DIR)) if _plat_lib_path not in sys.path: sys.path.append(_plat_lib_path) _lib_path = abspath(_LIB_DIR) if _lib_path not in sys.path: sys.path.append(_lib_path) del _LIB_DIR, _lib_path, _LIB32_DIR, _LIB64_DIR, _plat_lib_path import ldap from msr605 import MSR605
import shutil import struct import tempfile import time import utils from nova import vendor import M2Crypto from nova import exception from nova import flags FLAGS = flags.FLAGS flags.DEFINE_string('ca_file', 'cacert.pem', 'Filename of root CA') flags.DEFINE_string('keys_path', utils.abspath('../keys'), 'Where we keep our keys') flags.DEFINE_string('ca_path', utils.abspath('../CA'), 'Where we keep our root CA') flags.DEFINE_boolean('use_intermediate_ca', False, 'Should we use intermediate CAs for each project?') def ca_path(project_id): if project_id: return "%s/INTER/%s/cacert.pem" % (FLAGS.ca_path, project_id) return "%s/cacert.pem" % (FLAGS.ca_path) def fetch_ca(project_id=None, chain=True): if not FLAGS.use_intermediate_ca: project_id = None buffer = "" if project_id: with open(ca_path(project_id),"r") as cafile: buffer += cafile.read()
@version 0.0.1 @since 0.0.1 ''' from conf import C,log,BASE_DIR import utils import os import re import json from timestamp import html_link,html_script,html_img,all_url,all as allt from deps import DepsFinder from replace import replace from jinja2 import Template,Environment,FileSystemLoader,TemplateNotFound,TemplateSyntaxError _template_dir = C('template_dir') jinjaenv = Environment(loader = FileSystemLoader(utils.abspath(_template_dir), C('encoding') ), extensions = ["jinja2.ext.do"] , autoescape = True ) build_jinjaenv = Environment( loader = FileSystemLoader( os.path.join( os.getcwd() , C('build_dir'), _template_dir) , C('encoding') )) mgr_jinjaenv = Environment( loader = FileSystemLoader( os.path.join(BASE_DIR,'tpl') , C('encoding') )) def render_file(filename,data = None,noEnvironment = False,build = False): ''' 渲染文件 ''' if noEnvironment: body = mgr_jinjaenv.get_template(filename)#Template(utils.readfile(filename))#这里应为绝对路径 else: if build: body = build_jinjaenv.get_template(filename) else: body = jinjaenv.get_template(filename) return body.render(data or {})
def file_roots(request): file_roots = request.config.getini('SALT_FILE_ROOTS') if not file_roots: file_roots = [abspath(str(request.config.rootdir), '../')] return [str(p) for p in file_roots]
import os import contrib import anyjson import flags import utils FLAGS = flags.FLAGS flags.DEFINE_string('datastore_path', utils.abspath('../keeper'), 'where keys are stored on disk') class keeper(object): def __init__(self, prefix="nova-"): self.prefix = prefix try: os.mkdir(FLAGS.datastore_path) except: pass def _slugify(self, key): return key def __delitem__(self, item): item = self._slugify(item) path = "%s/%s%s" % (FLAGS.datastore_path, self.prefix, item) if os.path.isfile(path): os.remove(path) def __getitem__(self, item):
# figure out a bunch of directories so we don't need to parse them every time # Yay abstraction! waisman_user = False home_dir_str = None if utils.systemName in ('Linux', 'Darwin'): home_dir_str = utils.environ['HOME'] elif utils.systemName == 'Windows': try: # used by waisman users alone home_dir_str = utils.environ['_USR'] + '/' waisman_user = True except (AttributeError, KeyError): home_dir_str = utils.environ['USERPROFILE'] + '/' basedir, filename = utils.split(utils.abspath(__file__)) # within the package basedir = utils.split(basedir)[0] # move up one dir def if_path_not_found(path_key, path_dict): dir_path = filedialog.askdirectory( title="Please choose the directory for your %s file" % path_key) path_dict[path_key] = dir_path return dir_path #templatedir = utils.join(basedir, 'mapping_files') templatedir = path_finder.find_path("mapping_file_dir", func_if_path_not_found=if_path_not_found, func_if_path_empty=if_path_not_found)
def _addtimestamp(content,reg,base_dir,force_abspath=False): ''' 以base_dir为基础目录,在content中搜寻匹配reg的URL并尝试追加时间戳 reg:匹配URL的正则,其中\3为URL force_abspath:强制路径为绝对路径,即以WD为base_dir ''' iters=re.finditer(reg,content,re.I|re.M) t=C('timestamp_name') for it in reversed(list(iters)): start = content[0:it.start(1)] url = it.group(3) end = content[it.end(1):] local_url = replace(url) parsed_url = urlparse(local_url) parsed_query = parse_qs(parsed_url.query) #已经有时间戳的不再添加 #带协议的不再添加 if not local_url or not parsed_url.path: continue #具有模板语法的不予添加 elif parsed_url.path.find('{{') >=0 or parsed_url.path.find('{%') >= 0: log.warn('twig syntax found in %s'%parsed_url.path) continue elif re.match(r'^\s*(about:|data:|#)',local_url): log.warn('%s is an invalid url'%local_url) continue elif parsed_query.get(t) is not None: log.warn("%s has a timestamp"%local_url) continue elif parsed_url.scheme or local_url.startswith('//'): log.warn("%s has a scheme"%local_url) continue if os.path.isabs(parsed_url.path) or force_abspath: #绝对路径,则以当前工程根目录为root timestamp = utils.get_file_timestamp(utils.abspath(base_dir + parsed_url.path)) else: #相对目录,则此当前文件目录为root #应该仅在CSS内使用相对路径 timestamp = utils.get_file_timestamp(os.path.join(base_dir,parsed_url.path)) #计算不到时间戳则忽略 if not timestamp: continue parsed_url = urlparse(url) new_query = parsed_url.query if '' == new_query: new_query = t+"="+timestamp else: new_query+='&%s=%s'%(t,timestamp) if '' == parsed_url.fragment: new_fragment = '' else: new_fragment = '#'+parsed_url.fragment if not parsed_url.scheme: new_scheme = '' else: new_scheme = parsed_url.scheme+"://" new_url = new_scheme + parsed_url.netloc + parsed_url.path + '?' + new_query + new_fragment content = start + (it.group(2) or '') + new_url + (it.group(2) or '') + end return content
#!/usr/bin/env python3 # Generates a fizzbuzz, with some mistakes import utils MAX = 1000 OUTPUT = "fizzbuzz" FORMAT = "{}\t{}\n" def writeout(output, num, msg): output.write(FORMAT.format(num, msg)) with open(utils.abspath(OUTPUT), mode="w") as output: for num in range(MAX + 1): three = (num % 3) == 0 five = (num % 5) == 0 if num == 28: writeout(output, num, "Woof!") continue if num == 25: writeout(output, num, "Fizz") continue if num == 30: writeout(output, num, "Buzz") continue if three and five: writeout(output, num, "FizzBuzz")
default=5, help="epoch interval between exports of the model") parser.add("-o", "--output-dir", type=str, required=True, help="output dir for TensorBoard and models") parser.add("-mw", "--model-weights", type=str, default=None, help="weights file of trained model for training continuation") conf, unknown = parser.parse_known_args() # determine absolute filepaths conf.input_training = [utils.abspath(path) for path in conf.input_training] conf.label_training = utils.abspath(conf.label_training) conf.input_validation = [utils.abspath(path) for path in conf.input_validation] conf.label_validation = utils.abspath(conf.label_validation) conf.one_hot_palette_input = utils.abspath(conf.one_hot_palette_input) conf.one_hot_palette_label = utils.abspath(conf.one_hot_palette_label) conf.model = utils.abspath(conf.model) conf.unetxst_homographies = utils.abspath( conf.unetxst_homographies ) if conf.unetxst_homographies is not None else conf.unetxst_homographies conf.model_weights = utils.abspath( conf.model_weights ) if conf.model_weights is not None else conf.model_weights conf.output_dir = utils.abspath(conf.output_dir) # load network architecture module
if platform not in settings.platforms: raise RuntimeError("unknown platform '%s'" % platform) if toolchain not in settings.toolchains: raise RuntimeError("unknown toolchain '%s'" % toolchain) toolchain_settings = settings.toolchains[toolchain] if config not in settings.configs: raise RuntimeError("unknown config '%s'" % config) if target not in settings.targets: raise RuntimeError("unknown target '%s'" % target) print platform, toolchain, config, target # , args os.environ["SH_PATH"] = args.sh_path or "" src_dir = utils.abspath(target, args.src_dir) logger.debug("SRC_DIR=%s", src_dir) os.environ["SRC_DIR"] = src_dir build_dir = utils.makedirs(args.build_dir, platform, toolchain, config, target) logger.debug("BUILD_DIR=%s", build_dir) os.environ["BUILD_DIR"] = build_dir target_settings = utils.load_json( os.path.join(src_dir, BUILD_SETTINGS_FILENAME), {}) target_settings = get_by_alias(target_settings, platform, target_settings) target_settings = get_by_alias(target_settings, toolchain, target_settings) target_settings = get_by_alias(target_settings, config, target_settings) target_settings = Settings(disable=False,
import logging import M2Crypto import time import hashlib import os import utils import tempfile import shutil import contrib import flags FLAGS = flags.FLAGS flags.DEFINE_string('ca_file', 'cacert.pem', 'Filename of root CA') flags.DEFINE_string('keys_path', utils.abspath('../keys'), 'Where we keep our keys') flags.DEFINE_string('ca_path', utils.abspath('../CA'), 'Where we keep our root CA') def ca_path(username): if username: return "%s/INTER/%s/cacert.pem" % (FLAGS.ca_path, username) return "%s/cacert.pem" % (FLAGS.ca_path) def fetch_ca(username=None, chain=True): buffer = "" with open(ca_path(username), "r") as cafile: buffer += cafile.read()
# figure out a bunch of directories so we don't need to parse them every time # Yay abstraction! waisman_user = False home_dir_str = None if utils.systemName in ('Linux', 'Darwin'): home_dir_str = utils.environ['HOME'] elif utils.systemName == 'Windows': try: # used by waisman users alone home_dir_str = utils.environ['_USR'] + '/' waisman_user = True except (AttributeError, KeyError): home_dir_str = utils.environ['USERPROFILE'] + '/' basedir, filename = utils.split(utils.abspath(__file__)) # within the package basedir = utils.split(basedir)[0] # move up one dir def if_path_not_found(path_key, path_dict): dir_path = filedialog.askdirectory(title="Please choose the directory for your %s file"%path_key) path_dict[path_key] = dir_path return dir_path #templatedir = utils.join(basedir, 'mapping_files') templatedir = path_finder.find_path("mapping_file_dir", func_if_path_not_found=if_path_not_found , func_if_path_empty=if_path_not_found) srcdatdir = path_finder.find_path("source_data_dir", func_if_path_not_found=if_path_not_found , func_if_path_empty=if_path_not_found) sinkdatdir = path_finder.find_path("sink_data_dir", func_if_path_not_found=if_path_not_found,