Datasets:

h4iku
/

coconut_python2010_preprocessed

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
("type", "B"),	("mode", "I"), ("__pad0", "4x"),	def __repr__(self): return "<{0} {1}>".format(self.__class__.__name__, self.__values)
("links", "I"),)	("nlink", "I"), ("uid", "I"), ("gid", "I"), ("rdev", "Q"), ("atime", "I"), ("atimens", "I"), ("mtime", "I"), ("mtimens", "I"), ("ctime", "I"), ("ctimens", "I"), ("__pad1", "68x"),) def get_st_times(self): return dict(( ("st_" + a, self[a] + self[a + "ns"] / (10 ** 9)) for a in (b + "time" for b in "amc"))) assert Inode.size == 128, Inode.size	def __repr__(self): return "<{0} {1}>".format(self.__class__.__name__, self.__values)
assert BootRecord.size <= 256	assert BootRecord.size <= 256, "This will clobber the root directory entry"	def __repr__(self): return "<{0} {1}>".format(self.__class__.__name__, self.__values)
def __init__(self, path=None, fileobj=None): assert bool(path) ^ bool(fileobj) if path: self.f = open(path, "r+b") else: self.f = fileobj self.f.seek(0)	def __init__(self, path): self.f = open(path, "r+b")	def __init__(self, path=None, fileobj=None): assert bool(path) ^ bool(fileobj) if path: self.f = open(path, "r+b") else: self.f = fileobj self.f.seek(0) br = BootRecord.from_fileobj(self.f) assert br["ident"].rstrip("\0") == "clfs", repr(br["ident"]) assert br["version"] == 1 self.cluster_size = br["clrsize"] self.master_region_cluster_count = br["mstrclrs"] self.allocation_table_cluster_count = br["atabclrs"] self.data_region_cluster_count = br["dataclrs"] self.filesystem_cluster_count = \ self.master_region_cluster_count + \ self.allocation_table_cluster_count + \ self.data_region_cluster_count
self.filesystem_cluster_count = \ self.master_region_cluster_count + \	@property def filesystem_cluster_count(self): return self.master_region_cluster_count + \	def __init__(self, path=None, fileobj=None): assert bool(path) ^ bool(fileobj) if path: self.f = open(path, "r+b") else: self.f = fileobj self.f.seek(0) br = BootRecord.from_fileobj(self.f) assert br["ident"].rstrip("\0") == "clfs", repr(br["ident"]) assert br["version"] == 1 self.cluster_size = br["clrsize"] self.master_region_cluster_count = br["mstrclrs"] self.allocation_table_cluster_count = br["atabclrs"] self.data_region_cluster_count = br["dataclrs"] self.filesystem_cluster_count = \ self.master_region_cluster_count + \ self.allocation_table_cluster_count + \ self.data_region_cluster_count
if inode_struct["type"] != TYPE_DIRECTORY:	if not S_ISDIR(inode_struct["mode"]):	def read_directory(self, inode): inode_struct = self.get_inode_struct(inode) if inode_struct["type"] != TYPE_DIRECTORY: raise ClfsError(ENOTDIR) offset = 0 while offset < inode_struct["size"]: dirent = DirEntry.unpack(self.read_inode_data( inode, offset, DirEntry.size)) if dirent["name"].rstrip("\0"): yield dirent offset += dirent.size
for dirent in self.read_directory(cur_dirent["inode"]):	for dirent in self.read_directory(cur_dirent["ino"]):	def get_dir_entry(self, path): for name in path.split("/"): if not name: cur_dirent = self.get_root_dir_entry() else: # pdb.set_trace() for dirent in self.read_directory(cur_dirent["inode"]): if dirent["name"].rstrip("\0") == name: cur_dirent = dirent break else: raise ClfsError(ENOENT) return cur_dirent
def iter_allocation_table(self): self.seek_cluster(self.master_region_cluster_count) for index in xrange(self.data_region_cluster_count): yield struct.unpack("I", self.f.read(4))[0] def claim_free_cluster(self): self.seek_cluster(self.master_region_cluster_count) for index in xrange(self.data_region_cluster_count): cluster = struct.unpack("I", self.f.read(4))[0] if cluster == CLUSTER_FREE: self.f.seek(-4, os.SEEK_CUR) self.f.write(struct.pack("I", CLUSTER_END_OF_CHAIN)) return index + self.master_region_cluster_count + self.allocation_table_cluster_count else: assert False, "Filesystem is full?" def first_data_region_cluster_number(self): return self.master_region_cluster_count + self.allocation_table_cluster_count def valid_data_region_cluster_number(self, clno): return self.first_data_region_cluster_number() \ <= clno \ < self.filesystem_cluster_count def seek_cluster_number(self, clno): assert self.valid_data_region_cluster_number(clno), clno self.safe_seek(self.cluster_size * self.master_region_cluster_count + 4 * (clno - self.first_data_region_cluster_number())) def set_cluster_number(self, clno, value): self.seek_cluster_number(clno) logging.debug("Setting cluster number %i->%i", clno, value) self.f.write(struct.pack("I", value))	dirent_for_path = get_dir_entry	def get_dir_entry(self, path): for name in path.split("/"): if not name: cur_dirent = self.get_root_dir_entry() else: # pdb.set_trace() for dirent in self.read_directory(cur_dirent["inode"]): if dirent["name"].rstrip("\0") == name: cur_dirent = dirent break else: raise ClfsError(ENOENT) return cur_dirent
def write_inode_data(self, inode, offset, buffer): inode_struct = self.get_inode_struct(inode)	def write_inode_data(self, ino, offset, buffer): inode_struct = self.get_inode_struct(ino)	#def write(self, path, buf, offset):
inode,	ino,	def write_inode_data(self, inode, offset, buffer): inode_struct = self.get_inode_struct(inode) data_offset = inode_struct.size write_size, new_size = self.write_to_chain( inode, inode_struct["size"] + data_offset, offset + data_offset, buffer) assert write_size == len(buffer), write_size expected_size = data_offset + max(offset + write_size, inode_struct["size"]) assert new_size == expected_size, (new_size, expected_size) #assert new_size == # just update it anyway, i'll have to update times too inode_struct["size"] = new_size - data_offset #pdb.set_trace() assert (inode_struct.size, new_size) == self.write_to_chain( inode, new_size, 0, inode_struct.pack()) assert self.get_inode_struct(inode)["size"] == new_size - data_offset return write_size
inode, new_size, 0, inode_struct.pack()) assert self.get_inode_struct(inode)["size"] == new_size - data_offset	ino, new_size, 0, inode_struct.pack()) assert self.get_inode_struct(ino)["size"] == new_size - data_offset	def write_inode_data(self, inode, offset, buffer): inode_struct = self.get_inode_struct(inode) data_offset = inode_struct.size write_size, new_size = self.write_to_chain( inode, inode_struct["size"] + data_offset, offset + data_offset, buffer) assert write_size == len(buffer), write_size expected_size = data_offset + max(offset + write_size, inode_struct["size"]) assert new_size == expected_size, (new_size, expected_size) #assert new_size == # just update it anyway, i'll have to update times too inode_struct["size"] = new_size - data_offset #pdb.set_trace() assert (inode_struct.size, new_size) == self.write_to_chain( inode, new_size, 0, inode_struct.pack()) assert self.get_inode_struct(inode)["size"] == new_size - data_offset return write_size
def create_node(self, path, type):	def create_node(self, path, mode): """Create an allocate a new inode, update relevant structures elsewhere"""	def create_node(self, path, type): node_dirname, node_basename = os.path.split(path) parent_dirname, parent_basename = os.path.split(node_dirname) parent_dirent = self.get_dir_entry(node_dirname) parent_inode_struct = self.get_inode_struct(parent_dirent["inode"]) for dirent in self.read_directory(parent_dirent["inode"]): if dirent["name"].rstrip("\0") == node_basename: raise ClfsError(EEXIST) new_dirent = DirEntry(name=node_basename, inode=self.claim_free_cluster()) # write the new dirent at the end of the parent directory assert new_dirent.size == self.write_inode_data( parent_dirent["inode"], parent_inode_struct["size"], new_dirent.pack(),) # initialize the new inode #pdb.set_trace() new_inode = Inode(type=type, size=0) if type == TYPE_DIRECTORY: new_inode["links"] = 2 elif type == TYPE_REGULAR_FILE: new_inode["links"] = 1 assert (new_inode.size, new_inode.size) == self.write_to_chain( new_dirent["inode"], 0, 0, new_inode.pack())
parent_dirent = self.get_dir_entry(node_dirname) parent_inode_struct = self.get_inode_struct(parent_dirent["inode"]) for dirent in self.read_directory(parent_dirent["inode"]): if dirent["name"].rstrip("\0") == node_basename: raise ClfsError(EEXIST) new_dirent = DirEntry(name=node_basename, inode=self.claim_free_cluster())	create_rootdir = bool( (not node_basename) and (node_dirname == parent_dirname == "/")) if create_rootdir: assert S_ISDIR(mode) new_inode = Inode(size=0, uid=0, gid=0, rdev=0, mode=mode) sec, nsec = time_as_posix_spec(time()) for field_name in ("atime", "mtime", "ctime"): new_inode[field_name] = sec for field_name in ("atimens", "mtimens", "ctimens"): new_inode[field_name] = nsec del sec, nsec if S_ISDIR(mode): new_inode["nlink"] = 2 else: new_inode["nlink"] = 1 new_dirent = DirEntry(ino=self.claim_free_cluster()) if create_rootdir: new_dirent["name"] = "/" assert new_dirent["ino"] == self.first_data_region_cluster_number, new_dirent["ino"] else: parent_ino = self.dirent_for_path(node_dirname)["ino"] for sibling_dirent in self.read_directory(parent_ino): if sibling_dirent["name"] == node_basename: raise ClfsError(EEXIST) else: new_dirent["name"] = node_basename assert (new_inode.size, new_inode.size) == self.write_to_chain( cluster=new_dirent["ino"], size=0, offset=0, buffer=new_inode.pack())	def create_node(self, path, type): node_dirname, node_basename = os.path.split(path) parent_dirname, parent_basename = os.path.split(node_dirname) parent_dirent = self.get_dir_entry(node_dirname) parent_inode_struct = self.get_inode_struct(parent_dirent["inode"]) for dirent in self.read_directory(parent_dirent["inode"]): if dirent["name"].rstrip("\0") == node_basename: raise ClfsError(EEXIST) new_dirent = DirEntry(name=node_basename, inode=self.claim_free_cluster()) # write the new dirent at the end of the parent directory assert new_dirent.size == self.write_inode_data( parent_dirent["inode"], parent_inode_struct["size"], new_dirent.pack(),) # initialize the new inode #pdb.set_trace() new_inode = Inode(type=type, size=0) if type == TYPE_DIRECTORY: new_inode["links"] = 2 elif type == TYPE_REGULAR_FILE: new_inode["links"] = 1 assert (new_inode.size, new_inode.size) == self.write_to_chain( new_dirent["inode"], 0, 0, new_inode.pack())
assert new_dirent.size == self.write_inode_data( parent_dirent["inode"], parent_inode_struct["size"], new_dirent.pack(),) new_inode = Inode(type=type, size=0) if type == TYPE_DIRECTORY: new_inode["links"] = 2 elif type == TYPE_REGULAR_FILE: new_inode["links"] = 1 assert (new_inode.size, new_inode.size) == self.write_to_chain( new_dirent["inode"], 0, 0, new_inode.pack()) def create_filesystem(device_path): device_file = open(device_path, "r+b") device_size = os.fstat(device_file.fileno()).st_size	if create_rootdir: self.seek_root_dirent() self.f.write(new_dirent.pack()) else: assert new_dirent.size == self.write_inode_data( ino=parent_ino, offset=self.get_inode_struct(parent_ino)["size"], buffer=new_dirent.pack(),) def generate_bootrecord(device_size):	def create_node(self, path, type): node_dirname, node_basename = os.path.split(path) parent_dirname, parent_basename = os.path.split(node_dirname) parent_dirent = self.get_dir_entry(node_dirname) parent_inode_struct = self.get_inode_struct(parent_dirent["inode"]) for dirent in self.read_directory(parent_dirent["inode"]): if dirent["name"].rstrip("\0") == node_basename: raise ClfsError(EEXIST) new_dirent = DirEntry(name=node_basename, inode=self.claim_free_cluster()) # write the new dirent at the end of the parent directory assert new_dirent.size == self.write_inode_data( parent_dirent["inode"], parent_inode_struct["size"], new_dirent.pack(),) # initialize the new inode #pdb.set_trace() new_inode = Inode(type=type, size=0) if type == TYPE_DIRECTORY: new_inode["links"] = 2 elif type == TYPE_REGULAR_FILE: new_inode["links"] = 1 assert (new_inode.size, new_inode.size) == self.write_to_chain( new_dirent["inode"], 0, 0, new_inode.pack())
gtk.STOCK_NEW, gtk.RESPONSE_OK,	gtk.STOCK_OK, gtk.RESPONSE_OK,	def add_share(self, button): namelbl = gtk.Label("Share name:")
subprocess.check_call(["xdg-open", url])	try: subprocess.check_call(["xdg-open", url]) except subprocess.CalledProcessError as exc: print exc else: return	def browse_peer_by_url(self, url): """Open the given peer URL with the most natural file manager for the current platform that we can find""" import os, subprocess if os.name == "nt": # this is how it's done programmatically? except that it won't invoke # the default file manager (explorer) on winders #ShellExecute(None, "explore", url, None, None, SW_SHOWNORMAL)
subprocess.check_call(["nautilus", url])	try: subprocess.check_call(["nautilus", url]) except subprocess.CalledProcessError as exc: print exc else: return	def browse_peer_by_url(self, url): """Open the given peer URL with the most natural file manager for the current platform that we can find""" import os, subprocess if os.name == "nt": # this is how it's done programmatically? except that it won't invoke # the default file manager (explorer) on winders #ShellExecute(None, "explore", url, None, None, SW_SHOWNORMAL)
cluster_read_size = min(read_size, self.cluster_size - read_offset)	cluster_read_size = min(read_size, self.cluster_size - read_offset, chain_size)	def read_from_chain(self, first_cluster, chain_size, read_offset, read_size): if chain_size <= 0: return "" #assert read_offset + read_size <= chain_size, (read_offset, read_size, chain_size) if read_offset > self.cluster_size: return self.read_from_chain( self.next_cluster(first_cluster), chain_size - self.cluster_size, read_offset - self.cluster_size, read_size) cluster_read_size = min(read_size, self.cluster_size - read_offset) buffer = self.read_cluster(first_cluster, read_offset, cluster_read_size) assert len(buffer) == cluster_read_size return buffer + self.read_from_chain( self.next_cluster(first_cluster), chain_size - self.cluster_size, 0, read_size - cluster_read_size)
elif a.name in nopub_actions:	if a.name in nopub_actions:	def trans_include(repo_uri, fargs, transaction=None): basedirs = [] timestamp_files = [] error_occurred = False opts, pargs = getopt.getopt(fargs, "d:T:") for opt, arg in opts: if opt == "-d": basedirs.append(arg) elif opt == "-T": timestamp_files.append(arg) if transaction == None: try: trans_id = os.environ["PKG_TRANS_ID"] except KeyError: usage(_("No transaction ID specified in $PKG_TRANS_ID"), cmd="include") xport, pub = setup_transport_and_pubs(repo_uri) t = trans.Transaction(repo_uri, trans_id=trans_id, xport=xport, pub=pub) else: t = transaction if not pargs: filelist = [("<stdin>", sys.stdin)] else: try: filelist = [(f, file(f)) for f in pargs] except IOError, e: error(e, cmd="include") return 1 lines = [] # giant string of all input files concatenated together linecnts = [] # tuples of starting line number, ending line number linecounter = 0 # running total for filename, f in filelist: try: data = f.read() except IOError, e: error(e, cmd="include") return 1 lines.append(data) linecnt = len(data.splitlines()) linecnts.append((linecounter, linecounter + linecnt)) linecounter += linecnt m = pkg.manifest.Manifest() try: m.set_content("\n".join(lines)) except apx.InvalidPackageErrors, err: e = err.errors[0] lineno = e.lineno for i, tup in enumerate(linecnts): if lineno > tup[0] and lineno <= tup[1]: filename = filelist[i][0] lineno -= tup[0] break else: filename = "???" lineno = "???" error(_("File %s line %s: %s") % (filename, lineno, e), cmd="include") return 1 invalid_action = False for a in m.gen_actions(): # don't publish this action if a.name == "set" and a.attrs["name"] in ["pkg.fmri", "fmri"]: continue elif a.name == "file": path, bd = pkg.actions.set_action_data( a.hash, a, basedirs) basename = os.path.basename(a.attrs["path"]) for pattern in timestamp_files: if fnmatch.fnmatch(basename, pattern): ts = pkg.misc.time_to_timestamp( os.stat(path).st_mtime) a.attrs["timestamp"] = ts break elif a.name == "license": pkg.actions.set_action_data(a.hash, a, basedirs) elif a.name in nopub_actions: error(_("invalid action for publication: %s") % str(a), cmd="include") invalid_action = True else: t.add(a) if invalid_action: return 3 else: return 0
self.pkgsend_bulk(durl, self.example_pkg10)	self.pkgsend_bulk(durl, self.dup_lines_pkg10)	def test_bug_12271_14088(self): """Check that consecutive duplicate lines are removed and that having a single option to -o still prints the header."""
self.pkg("search 'example_pkg:set:pkg.fmri:'")	self.pkg("search 'dup_lines:set:pkg.fmri:'")	def test_bug_12271_14088(self): """Check that consecutive duplicate lines are removed and that having a single option to -o still prints the header."""
self.pkg("search -o pkg.shortfmri '6'")	self.pkg("search -o pkg.shortfmri 'a'")	def test_bug_12271_14088(self): """Check that consecutive duplicate lines are removed and that having a single option to -o still prints the header."""
self.pkg("install example_pkg") self.pkg("search -l 'example_pkg:set:pkg.fmri:'")	self.pkg("install dup_lines") self.pkg("search -l 'dup_lines:set:pkg.fmri:'")	def test_bug_12271_14088(self): """Check that consecutive duplicate lines are removed and that having a single option to -o still prints the header."""
self.pkg("search -l -o pkg.shortfmri,action.key '6'") expected_number_of_lines = 9 if "pkg.fmri" in self.output: expected_number_of_lines += 1 self.debug("Expected number of lines:%s" % expected_number_of_lines) self.assertEqual(len(self.output.splitlines()), expected_number_of_lines)	self.pkg("search -l -o pkg.shortfmri,action.key 'a'") self.assertEqual(len(self.output.splitlines()), 4)	def test_bug_12271_14088(self): """Check that consecutive duplicate lines are removed and that having a single option to -o still prints the header."""
("show_on_expected_fail", 'f',	("showonexpectedfail", 'f',	def run(self): # nuke everything print("deleting " + dist_dir) shutil.rmtree(dist_dir, True) print("deleting " + build_dir) shutil.rmtree(build_dir, True) print("deleting " + root_dir) shutil.rmtree(root_dir, True) print("deleting " + pkgs_dir) shutil.rmtree(pkgs_dir, True) print("deleting " + extern_dir) shutil.rmtree(extern_dir, True)
self.show_on_expected_fail = 0	self.showonexpectedfail = 0	def initialize_options(self): self.only = "" self.baselinefile = "" self.verbosemode = 0 self.parseable = 0 self.genbaseline = 0 self.timing = 0 self.coverage = 0 self.stoponerr = 0 self.debugoutput = 0 self.show_on_expected_fail = 0 self.startattest = "" self.archivedir = ""
remote_publishers=True)	remote_prefix=True)	def main_func(): global cache_dir, download_start, xport, xport_cfg all_timestamps = False all_versions = False keep_compressed = False list_newest = False recursive = False src_uri = None target = None incoming_dir = None src_pub = None targ_pub = None temp_root = misc.config_temp_root() gettext.install("pkg", "/usr/share/locale") global_settings.client_name = "pkgrecv" target = os.environ.get("PKG_DEST", None) src_uri = os.environ.get("PKG_SRC", None) try: opts, pargs = getopt.getopt(sys.argv[1:], "c:d:hkm:nrs:") except getopt.GetoptError, e: usage(_("Illegal option -- %s") % e.opt) for opt, arg in opts: if opt == "-c": cache_dir = arg elif opt == "-d": target = arg elif opt == "-h": usage(retcode=0) elif opt == "-k": keep_compressed = True elif opt == "-n": list_newest = True elif opt == "-r": recursive = True elif opt == "-s": src_uri = arg elif opt == "-m": if arg == "all-timestamps": all_timestamps = True elif arg == "all-versions": all_versions = True else: usage(_("Illegal option value -- %s") % arg) if not src_uri: usage(_("a source repository must be provided")) if not cache_dir: cache_dir = tempfile.mkdtemp(dir=temp_root) # Only clean-up cache dir if implicitly created by pkgrecv. # User's cache-dirs should be preserved tmpdirs.append(cache_dir) incoming_dir = tempfile.mkdtemp(dir=temp_root) tmpdirs.append(incoming_dir) # Create transport and transport config xport, xport_cfg = transport.setup_transport() xport_cfg.cached_download_dir = cache_dir xport_cfg.incoming_download_dir = incoming_dir # Since publication destionations may only have one repository # configured per publisher, create destination as separate transport # in case source and destination have identical publisher configuration # but different repository endpoints. dest_xport, dest_xport_cfg = transport.setup_transport() dest_xport_cfg.cached_download_dir = cache_dir dest_xport_cfg.incoming_download_dir = incoming_dir # Configure src publisher src_pub = transport.setup_publisher(src_uri, "source", xport, xport_cfg, remote_publishers=True) tracker = get_tracker() if list_newest: if pargs or len(pargs) > 0: usage(_("-n takes no options")) fmri_list = fetch_catalog(src_pub, tracker, xport) list_newest_fmris(fmri_list) return 0 if pargs == None or len(pargs) == 0: usage(_("must specify at least one pkgfmri")) republish = False if not target: target = basedir = os.getcwd() elif target.find("://") != -1: basedir = tempfile.mkdtemp(dir=temp_root) tmpdirs.append(basedir) republish = True targ_pub = transport.setup_publisher(target, "target", dest_xport, dest_xport_cfg, remote_publishers=True) # Files have to be decompressed for republishing. keep_compressed = False if target.startswith("file://"): # Check to see if the repository exists first. try: t = trans.Transaction(target, xport=dest_xport, pub=targ_pub) except trans.TransactionRepositoryInvalidError, e: txt = str(e) + "\n\n" txt += _("To create a repository, use the " "pkgsend command.") abort(err=txt) except trans.TransactionRepositoryConfigError, e: txt = str(e) + "\n\n" txt += _("The repository configuration for " "the repository located at '%s' is not " "valid or the specified path does not " "exist. Please correct the configuration " "of the repository or create a new " "one.") % target abort(err=txt) except trans.TransactionError, e: abort(err=e) else: basedir = target if not os.path.exists(basedir): try: os.makedirs(basedir, misc.PKG_DIR_MODE) except: error(_("Unable to create basedir '%s'.") % \ basedir) return 1 xport_cfg.pkgdir = basedir if republish: targ_fmris = fetch_catalog(targ_pub, tracker, dest_xport) all_fmris = fetch_catalog(src_pub, tracker, xport) fmri_arguments = pargs fmri_list = prune(list(set(expand_matching_fmris(all_fmris, fmri_arguments))), all_versions, all_timestamps) if recursive: msg(_("Retrieving manifests for dependency evaluation ...")) tracker.evaluate_start() fmri_list = prune(get_dependencies(src_uri, fmri_list, basedir, tracker), all_versions, all_timestamps) tracker.evaluate_done() def get_basename(pfmri): open_time = pfmri.get_timestamp() return "%d_%s" % \ (calendar.timegm(open_time.utctimetuple()), urllib.quote(str(pfmri), "")) # First, retrieve the manifests and calculate package transfer sizes. npkgs = len(fmri_list) nfiles = 0 nbytes = 0 if not recursive: msg(_("Retrieving manifests for package evaluation ...")) tracker.evaluate_start(npkgs=npkgs) retrieve_list = [] while fmri_list: f = fmri_list.pop() if republish and f in targ_fmris: msg(_("Skipping %s: already present " "at destination") % f) continue m = get_manifest(f, basedir) pkgdir = os.path.join(basedir, f.get_dir_path()) mfile = xport.multi_file_ni(src_pub, pkgdir, not keep_compressed, tracker) nf, nb = add_hashes_to_multi(m, mfile) nfiles += nf nbytes += nb retrieve_list.append((f, mfile)) tracker.evaluate_progress(fmri=f) tracker.evaluate_done() # Next, retrieve and store the content for each package. msg(_("Retrieving package content ...")) tracker.download_set_goal(len(retrieve_list), nfiles, nbytes) publish_list = [] while retrieve_list: f, mfile = retrieve_list.pop() tracker.download_start_pkg(f.get_fmri(include_scheme=False)) if mfile: mfile.wait_files() if not download_start: download_start = True if republish: publish_list.append(f) tracker.download_end_pkg() tracker.download_done() tracker.reset() # Finally, republish the packages if needed. while publish_list: f = publish_list.pop() msg(_("Republishing %s ...") % f) m = get_manifest(f, basedir) # Get first line of original manifest so that inclusion of the # scheme can be determined. use_scheme = True contents = get_manifest(f, basedir, contents=True) if contents.splitlines()[0].find("pkg:/") == -1: use_scheme = False pkg_name = f.get_fmri(include_scheme=use_scheme) pkgdir = os.path.join(basedir, f.get_dir_path()) # This is needed so any previous failures for a package # can be aborted. trans_id = get_basename(f) if not targ_pub: targ_pub = transport.setup_publisher(target, "target", dest_xport, dest_xport_cfg, remote_publishers=True) try: t = trans.Transaction(target, pkg_name=pkg_name, trans_id=trans_id, xport=dest_xport, pub=targ_pub) # Remove any previous failed attempt to # to republish this package. try: t.close(abandon=True) except: # It might not exist already. pass t.open() for a in m.gen_actions(): if a.name == "set" and \ a.attrs.get("name", "") in ("fmri", "pkg.fmri"): # To be consistent with the server, # the fmri can't be added to the # manifest. continue if hasattr(a, "hash"): fname = os.path.join(pkgdir, a.hash) a.data = lambda: open(fname, "rb") t.add(a) t.close() except trans.TransactionError, e: abort(err=e) return 1 # Dump all temporary data. cleanup() return 0
dest_xport, dest_xport_cfg, remote_publishers=True)	dest_xport, dest_xport_cfg, remote_prefix=True)	def main_func(): global cache_dir, download_start, xport, xport_cfg all_timestamps = False all_versions = False keep_compressed = False list_newest = False recursive = False src_uri = None target = None incoming_dir = None src_pub = None targ_pub = None temp_root = misc.config_temp_root() gettext.install("pkg", "/usr/share/locale") global_settings.client_name = "pkgrecv" target = os.environ.get("PKG_DEST", None) src_uri = os.environ.get("PKG_SRC", None) try: opts, pargs = getopt.getopt(sys.argv[1:], "c:d:hkm:nrs:") except getopt.GetoptError, e: usage(_("Illegal option -- %s") % e.opt) for opt, arg in opts: if opt == "-c": cache_dir = arg elif opt == "-d": target = arg elif opt == "-h": usage(retcode=0) elif opt == "-k": keep_compressed = True elif opt == "-n": list_newest = True elif opt == "-r": recursive = True elif opt == "-s": src_uri = arg elif opt == "-m": if arg == "all-timestamps": all_timestamps = True elif arg == "all-versions": all_versions = True else: usage(_("Illegal option value -- %s") % arg) if not src_uri: usage(_("a source repository must be provided")) if not cache_dir: cache_dir = tempfile.mkdtemp(dir=temp_root) # Only clean-up cache dir if implicitly created by pkgrecv. # User's cache-dirs should be preserved tmpdirs.append(cache_dir) incoming_dir = tempfile.mkdtemp(dir=temp_root) tmpdirs.append(incoming_dir) # Create transport and transport config xport, xport_cfg = transport.setup_transport() xport_cfg.cached_download_dir = cache_dir xport_cfg.incoming_download_dir = incoming_dir # Since publication destionations may only have one repository # configured per publisher, create destination as separate transport # in case source and destination have identical publisher configuration # but different repository endpoints. dest_xport, dest_xport_cfg = transport.setup_transport() dest_xport_cfg.cached_download_dir = cache_dir dest_xport_cfg.incoming_download_dir = incoming_dir # Configure src publisher src_pub = transport.setup_publisher(src_uri, "source", xport, xport_cfg, remote_publishers=True) tracker = get_tracker() if list_newest: if pargs or len(pargs) > 0: usage(_("-n takes no options")) fmri_list = fetch_catalog(src_pub, tracker, xport) list_newest_fmris(fmri_list) return 0 if pargs == None or len(pargs) == 0: usage(_("must specify at least one pkgfmri")) republish = False if not target: target = basedir = os.getcwd() elif target.find("://") != -1: basedir = tempfile.mkdtemp(dir=temp_root) tmpdirs.append(basedir) republish = True targ_pub = transport.setup_publisher(target, "target", dest_xport, dest_xport_cfg, remote_publishers=True) # Files have to be decompressed for republishing. keep_compressed = False if target.startswith("file://"): # Check to see if the repository exists first. try: t = trans.Transaction(target, xport=dest_xport, pub=targ_pub) except trans.TransactionRepositoryInvalidError, e: txt = str(e) + "\n\n" txt += _("To create a repository, use the " "pkgsend command.") abort(err=txt) except trans.TransactionRepositoryConfigError, e: txt = str(e) + "\n\n" txt += _("The repository configuration for " "the repository located at '%s' is not " "valid or the specified path does not " "exist. Please correct the configuration " "of the repository or create a new " "one.") % target abort(err=txt) except trans.TransactionError, e: abort(err=e) else: basedir = target if not os.path.exists(basedir): try: os.makedirs(basedir, misc.PKG_DIR_MODE) except: error(_("Unable to create basedir '%s'.") % \ basedir) return 1 xport_cfg.pkgdir = basedir if republish: targ_fmris = fetch_catalog(targ_pub, tracker, dest_xport) all_fmris = fetch_catalog(src_pub, tracker, xport) fmri_arguments = pargs fmri_list = prune(list(set(expand_matching_fmris(all_fmris, fmri_arguments))), all_versions, all_timestamps) if recursive: msg(_("Retrieving manifests for dependency evaluation ...")) tracker.evaluate_start() fmri_list = prune(get_dependencies(src_uri, fmri_list, basedir, tracker), all_versions, all_timestamps) tracker.evaluate_done() def get_basename(pfmri): open_time = pfmri.get_timestamp() return "%d_%s" % \ (calendar.timegm(open_time.utctimetuple()), urllib.quote(str(pfmri), "")) # First, retrieve the manifests and calculate package transfer sizes. npkgs = len(fmri_list) nfiles = 0 nbytes = 0 if not recursive: msg(_("Retrieving manifests for package evaluation ...")) tracker.evaluate_start(npkgs=npkgs) retrieve_list = [] while fmri_list: f = fmri_list.pop() if republish and f in targ_fmris: msg(_("Skipping %s: already present " "at destination") % f) continue m = get_manifest(f, basedir) pkgdir = os.path.join(basedir, f.get_dir_path()) mfile = xport.multi_file_ni(src_pub, pkgdir, not keep_compressed, tracker) nf, nb = add_hashes_to_multi(m, mfile) nfiles += nf nbytes += nb retrieve_list.append((f, mfile)) tracker.evaluate_progress(fmri=f) tracker.evaluate_done() # Next, retrieve and store the content for each package. msg(_("Retrieving package content ...")) tracker.download_set_goal(len(retrieve_list), nfiles, nbytes) publish_list = [] while retrieve_list: f, mfile = retrieve_list.pop() tracker.download_start_pkg(f.get_fmri(include_scheme=False)) if mfile: mfile.wait_files() if not download_start: download_start = True if republish: publish_list.append(f) tracker.download_end_pkg() tracker.download_done() tracker.reset() # Finally, republish the packages if needed. while publish_list: f = publish_list.pop() msg(_("Republishing %s ...") % f) m = get_manifest(f, basedir) # Get first line of original manifest so that inclusion of the # scheme can be determined. use_scheme = True contents = get_manifest(f, basedir, contents=True) if contents.splitlines()[0].find("pkg:/") == -1: use_scheme = False pkg_name = f.get_fmri(include_scheme=use_scheme) pkgdir = os.path.join(basedir, f.get_dir_path()) # This is needed so any previous failures for a package # can be aborted. trans_id = get_basename(f) if not targ_pub: targ_pub = transport.setup_publisher(target, "target", dest_xport, dest_xport_cfg, remote_publishers=True) try: t = trans.Transaction(target, pkg_name=pkg_name, trans_id=trans_id, xport=dest_xport, pub=targ_pub) # Remove any previous failed attempt to # to republish this package. try: t.close(abandon=True) except: # It might not exist already. pass t.open() for a in m.gen_actions(): if a.name == "set" and \ a.attrs.get("name", "") in ("fmri", "pkg.fmri"): # To be consistent with the server, # the fmri can't be added to the # manifest. continue if hasattr(a, "hash"): fname = os.path.join(pkgdir, a.hash) a.data = lambda: open(fname, "rb") t.add(a) t.close() except trans.TransactionError, e: abort(err=e) return 1 # Dump all temporary data. cleanup() return 0
dest_xport, dest_xport_cfg, remote_publishers=True)	dest_xport, dest_xport_cfg, remote_prefix=True)	def get_basename(pfmri): open_time = pfmri.get_timestamp() return "%d_%s" % \ (calendar.timegm(open_time.utctimetuple()), urllib.quote(str(pfmri), ""))
publisher_info = self._get_getpublisherinfo(pub,	publisher_info = self._get_publisherinfo(pub,	def get_publisherinfo(self, pub, ccancel=None): """Given a publisher pub, return the publisher/0 information in a StringIO object."""
if not_these_pkgs: newpkgs = set(pkgdict[name] for name in pkgdict.keys() if name not in not_these_pkgs ) else: newpkgs = set(pkgdict.values())		def main_func(): global file_repo global def_branch global def_repo global def_vers global extra_entire_contents global just_these_pkgs global not_these_pkgs global nopublish global publish_all global print_pkg_names global reference_uris global show_debug global wos_path global not_these_consolidations global curpkg try: _opts, _args = getopt.getopt(sys.argv[1:], "AB:C:D:E:I:J:G:NR:T:b:dj:m:ns:v:w:p:") except getopt.GetoptError, _e: print "unknown option", _e.opt sys.exit(1) g_proto_area = os.environ.get("ROOT", "") for opt, arg in _opts: if opt == "-b": def_branch = arg.rstrip("abcdefghijklmnopqrstuvwxyz") elif opt == "-d": show_debug = True elif opt == "-j": # means we're using the new argument form... just_these_pkgs.append(arg) elif opt == "-m": _a = arg.split("=", 1) set_macro(_a[0], _a[1]) elif opt == "-n": nopublish = True elif opt == "-p": if not os.path.exists(arg): raise RuntimeError("Invalid prototype area specified.") # Clean up relative ../../, etc. out of path to proto g_proto_area = os.path.realpath(arg) elif opt == "-s": def_repo = arg if def_repo.startswith("file://"): file_repo = True elif opt == "-v": def_vers = arg elif opt == "-w": wos_path.append(arg) elif opt == "-A": # Always publish obsoleted and renamed packages. publish_all = True elif opt == "-B": branch_file = file(arg) for _line in branch_file: if not _line.startswith("#"): bfargs = _line.split() if len(bfargs) == 2: branch_dict[bfargs[0]] = bfargs[1] branch_file.close() elif opt == "-C": not_these_consolidations.append(arg) elif opt == "-D": elided_files[arg] = True elif opt == "-E": if "@" not in arg: print "-E fmris require a version: %s" % arg sys.exit(2) extra_entire_contents.append(arg) elif opt == "-I": include_path.extend(arg.split(":")) elif opt == "-J": not_these_pkgs.append(arg) elif opt == "-G": #another file of global includes global_includes.append(arg) elif opt == "-N": print_pkg_names = True elif opt == "-R": reference_uris.append(arg) elif opt == "-T": timestamp_files.append(arg) if not def_branch: print "need a branch id (build number)" sys.exit(2) elif "." not in def_branch: print "branch id needs to be of the form 'x.y'" sys.exit(2) if not _args: print "need argument!" sys.exit(2) if not wos_path: wos_path = def_wos_path if just_these_pkgs: filelist = _args else: filelist = _args[0:1] just_these_pkgs = _args[1:] if print_pkg_names: for _mf in filelist: SolarisParse(_mf) sys.exit(0) start_time = time.clock() print "First pass: initial import", datetime.now() for _mf in filelist: SolarisParse(_mf) # Remove pkgs we're not touching because we're skipping that # consolidation pkgs_to_elide = [ p.name for p in pkgdict.values() if p.consolidation in not_these_consolidations ] for pkg in pkgs_to_elide: del pkgdict[pkg] for pkg in not_these_pkgs: del pkgdict[pkg] # Unless we are publishing all obsolete and renamed packages # (-A command line option), remove obsolete and renamed packages # that weren't obsoleted or renamed at this branch and create # a dictionary (called or_pkgs_per_con) of obsoleted and renamed # packages per consolidation. The version portion of the fmri # will contain the branch that the package was obsoleted or renamed at. or_pkgs_per_con = {} obs_or_renamed_pkgs = {} for pkg in pkgdict.keys(): obs_branch = pkgdict[pkg].obsolete_branch rename_branch = pkgdict[pkg].rename_branch ver_tokens = pkgdict[pkg].version.split(".") cons = pkgdict[pkg].consolidation if obs_branch: ver_tokens[-1] = obs_branch ver_string = ".".join(ver_tokens) or_pkgs_per_con.setdefault(cons, {})[pkg] = ver_string obs_or_renamed_pkgs[pkg] = (pkgdict[pkg].fmristr(), "obsolete") if publish_all: pkgdict[pkg].version = ver_string else: if obs_branch != def_branch.split(".")[1]: # Not publishing this obsolete package. del pkgdict[pkg] if rename_branch: ver_tokens[-1] = rename_branch ver_string = ".".join(ver_tokens) or_pkgs_per_con.setdefault(cons, {})[pkg] = ver_string obs_or_renamed_pkgs[pkg] = (pkgdict[pkg].fmristr(), "renamed") if publish_all: pkgdict[pkg].version = ver_string else: if rename_branch != def_branch.split(".")[1]: # Not publishing this renamed package. del pkgdict[pkg] print "Second pass: global crosschecks", datetime.now() # perform global crosschecks # path_dict.clear() for pkg in pkgdict.values(): for action in pkg.actions: if "path" not in action.attrs: continue path = action.attrs["path"] path_dict.setdefault(path, []).append(action) if action.name in ["file", "link", "hardlink"]: basename_dict.setdefault(os.path.basename(path), []).append(action) pkgpath_dict.setdefault(path, []).append(action.attrs["importer.ipspkg"]) errors = check_pathdict_actions(path_dict) if errors: for e in errors: print "Fail: %s" % e sys.exit(1) # check for require dependencies on obsolete or renamed pkgs errors = [] warns = [] for pack in pkgdict.values(): for action in pack.actions: if action.name != "depend": continue if action.attrs["type"] == "require" and "fmri" in action.attrs: fmri = action.attrs["fmri"].split("@")[0] # remove version if fmri.startswith("pkg:/"): # remove pkg:/ if exists fmri = fmri[5:] if fmri in obs_or_renamed_pkgs: tup = obs_or_renamed_pkgs[fmri] s = "Pkg %s has 'require' dependency on pkg %s, which is %s" % ( (pack.fmristr(),) + tup) if tup[1] == "obsolete": errors.append(s) else: warns.append(s) if warns: for w in warns: print "Warn: %s" % w if errors: for e in errors: print "Fail: %s" % e sys.exit(1) print "packages being published are self consistent" if reference_uris: print "downloading and checking external references" excludes = [variant.Variants({"variant.arch": get_arch()}).allow_action] for uri in reference_uris: server, fmri_string = uri.split("@", 1) for pfmri in get_dependencies(server, [fmri_string]): if pfmri.get_name() in pkgdict: continue # ignore pkgs already seen pfmri_str = "%s@%s" % (pfmri.get_name(), pfmri.get_version()) fmridict[pfmri.get_name()] = pfmri_str for action in get_manifest(server, pfmri).gen_actions(excludes): if "path" not in action.attrs: continue if action.name == "unknown": # we don't care about unknown actions - # mispublished packages with eg. SVR4 # pkginfo files result in duplicate paths, # causing errors in check_pathdict_actions # "Multiple actions on different types # with the same path" print "INFO: ignoring action in %s: %s" \ % (pfmri_str, str(action)) continue action.attrs["importer.ipspkg"] = pfmri_str path_dict.setdefault(action.attrs["path"], []).append(action) if action.name in ["file", "link", "hardlink"]: basename_dict.setdefault(os.path.basename( action.attrs["path"]), []).append(action) pkgpath_dict.setdefault(action.attrs["path"], []).append(action.attrs["importer.ipspkg"]) errors = check_pathdict_actions(path_dict) if errors: for e in errors: print "Fail: %s" % e sys.exit(1) print "external packages checked for conflicts" print "Third pass: dependency id, resolution and publication", datetime.now() consolidation_incorporations = [] obsoleted_renamed_pkgs = [] # Generate consolidation incorporations for cons in cons_dict.keys(): if cons in not_these_consolidations: print "skipping consolidation %s" % cons continue consolidation_incorporation = "consolidation/%s/%s-incorporation" % ( cons, cons) consolidation_incorporations.append(consolidation_incorporation) curpkg = start_package(consolidation_incorporation) curpkg.summary = "%s consolidation incorporation" % cons curpkg.desc = "This incorporation constrains packages " \ "from the %s consolidation." % cons # Add packages that aren't renamed or obsoleted or_pkgs = or_pkgs_per_con.get(cons, {}) curpkg.actions.append(actions.fromstr( "set name=pkg.depend.install-hold value=core-os.%s" % cons)) for depend in cons_dict[cons]: if depend not in or_pkgs: action = actions.fromstr( "depend fmri=%s type=incorporate" % depend) action.attrs["importer.source"] = "depend" curpkg.actions.append(action) # Add in the obsoleted and renamed packages for this # consolidation. for name, version in or_pkgs.iteritems(): action = actions.fromstr( "depend fmri=%s@%s type=incorporate" % (name, version)) action.attrs["importer.source"] = "depend" curpkg.actions.append(action) obsoleted_renamed_pkgs.append("%s@%s" % (name, version)) action = actions.fromstr("set " \ "name=org.opensolaris.consolidation value=%s" % cons) action.attrs["importer.source"] = "add" curpkg.actions.append(action) end_package(curpkg) curpkg = None # Generate entire consolidation if we're generating any consolidation incorps if consolidation_incorporations: curpkg = start_package("entire") curpkg.summary = "incorporation to lock all system packages to same build" curpkg.desc = "This package constrains " \ "system package versions to the same build. WARNING: Proper " \ "system update and correct package selection depend on the " \ "presence of this incorporation. Removing this package will " \ "result in an unsupported system." curpkg.actions.append(actions.fromstr( "set name=pkg.depend.install-hold value=core-os")) for incorp in consolidation_incorporations: action = actions.fromstr("depend fmri=%s type=incorporate" % incorp) action.attrs["importer.source"] = "auto-generated" curpkg.actions.append(action) action = actions.fromstr("depend fmri=%s type=require" % incorp) action.attrs["importer.source"] = "auto-generated" action.attrs["importer.no-version"] = "true" curpkg.actions.append(action) for extra in extra_entire_contents: action = actions.fromstr("depend fmri=%s type=incorporate" % extra) action.attrs["importer.source"] = "command-line" curpkg.actions.append(action) extra_noversion = extra.split("@")[0] # remove version action = actions.fromstr("depend fmri=%s type=require" % extra_noversion) action.attrs["importer.source"] = "command-line" action.attrs["importer.no-version"] = "true" curpkg.actions.append(action) end_package(curpkg) curpkg = None incorporated_pkgs = set([ f for l in cons_dict.values() for f in l ]) incorporated_pkgs \|= set(consolidation_incorporations) incorporated_pkgs \|= set(["entire", "redistributable"]) incorporated_pkgs \|= set(obsoleted_renamed_pkgs) unincorps = set(pkgdict.keys()) - incorporated_pkgs if unincorps: # look through these; if they have only set actions they're # ancient obsoleted pkgs - ignore them. for f in unincorps.copy(): for a in pkgdict[f].actions: if a.name != "set": break else: unincorps.remove(f) print "The following non-empty unincorporated pkgs are not part of any consolidation" for f in unincorps: print f if just_these_pkgs: newpkgs = set(pkgdict[name] for name in pkgdict.keys() if name in just_these_pkgs ) else: newpkgs = set(pkgdict.values()) if not_these_pkgs: newpkgs = set(pkgdict[name] for name in pkgdict.keys() if name not in not_these_pkgs ) else: newpkgs = set(pkgdict.values()) if not_these_consolidations: newpkgs = set([ p for p in newpkgs if not p.delivered_via_ips() ]) processed = 0 total = len(newpkgs) error_count = 0 for _p in sorted(newpkgs): if show_debug: print " Version:", _p.version print " Description:", _p.desc print " Summary:", _p.summary print " Classification:", ",".join(_p.classification) try: publish_pkg(_p) except trans.TransactionError, _e: print "%s: FAILED: %s\n" % (_p.name, _e) error_count += 1 processed += 1 if show_debug: print "%d/%d packages processed; %.2f%% complete" % (processed, total, processed * 100.0 / total) if error_count: print "%d/%d packages has errors; %.2f%% FAILED" % (error_count, total, error_count * 100.0 / total) sys.exit(1) print "%d/%d packages processed; %.2f%% complete" % (processed, total, processed * 100.0 / total) if file_repo: code = repo_add_content(def_repo[7:], g_proto_area) if code: sys.exit(code) print "Done:", datetime.now() elapsed = time.clock() - start_time print "publication took %d:%.2d" % (elapsed/60, elapsed % 60) sys.exit(0)
pub_name = "opensolaris.org"		def get_smf_packages(server_url, manifest_locations, filter): """ Performs a search against server_url looking for packages which contain SMF manifests, returning a list of those pfmris """ dir = os.getcwd() tracker = pkg.client.progress.QuietProgressTracker() image_dir = tempfile.mkdtemp("", "pkg_importer_smfsearch.") is_zone = False pub_name = "opensolaris.org" refresh_allowed = True # create a temporary image api_inst = pkg.client.api.image_create(PKG_CLIENT_NAME, CLIENT_API_VERSION, image_dir, pkg.client.api.IMG_TYPE_USER, is_zone, facets=pkg.facet.Facets(), force=False, prefix=pub_name, progtrack=tracker, refresh_allowed=refresh_allowed, repo_uri=server_url) api_inst = pkg.client.api.ImageInterface(image_dir, pkg.client.api.CURRENT_API_VERSION, tracker, None, PKG_CLIENT_NAME) # restore the current directory, which ImageInterace had changed os.chdir(dir) searches = [] fmris = set() case_sensitive = False return_actions = True query = [] for manifest_loc in manifest_locations: query.append(pkg.client.api.Query(":directory:path:/%s" % manifest_loc, case_sensitive, return_actions)) searches.append(api_inst.remote_search(query)) shutil.rmtree(image_dir, True) for item in searches: for result in item: pfmri = None try: query_num, pub, (v, return_type, tmp) = result pfmri, index, action = tmp except ValueError: raise if pfmri is None: continue if filter in pfmri.get_fmri(): fmris.add(pfmri.get_fmri()) return [pkg.fmri.PkgFmri(pfmri) for pfmri in fmris]
is_zone, facets=pkg.facet.Facets(), force=False, prefix=pub_name,	is_zone, facets=pkg.facet.Facets(), force=False,	def get_smf_packages(server_url, manifest_locations, filter): """ Performs a search against server_url looking for packages which contain SMF manifests, returning a list of those pfmris """ dir = os.getcwd() tracker = pkg.client.progress.QuietProgressTracker() image_dir = tempfile.mkdtemp("", "pkg_importer_smfsearch.") is_zone = False pub_name = "opensolaris.org" refresh_allowed = True # create a temporary image api_inst = pkg.client.api.image_create(PKG_CLIENT_NAME, CLIENT_API_VERSION, image_dir, pkg.client.api.IMG_TYPE_USER, is_zone, facets=pkg.facet.Facets(), force=False, prefix=pub_name, progtrack=tracker, refresh_allowed=refresh_allowed, repo_uri=server_url) api_inst = pkg.client.api.ImageInterface(image_dir, pkg.client.api.CURRENT_API_VERSION, tracker, None, PKG_CLIENT_NAME) # restore the current directory, which ImageInterace had changed os.chdir(dir) searches = [] fmris = set() case_sensitive = False return_actions = True query = [] for manifest_loc in manifest_locations: query.append(pkg.client.api.Query(":directory:path:/%s" % manifest_loc, case_sensitive, return_actions)) searches.append(api_inst.remote_search(query)) shutil.rmtree(image_dir, True) for item in searches: for result in item: pfmri = None try: query_num, pub, (v, return_type, tmp) = result pfmri, index, action = tmp except ValueError: raise if pfmri is None: continue if filter in pfmri.get_fmri(): fmris.add(pfmri.get_fmri()) return [pkg.fmri.PkgFmri(pfmri) for pfmri in fmris]
self.write(cursor, user, id, {db_field: value}, context=context)	self.write(cursor, user, id, { db_field: datetime.datetime.combine(value, datetime.time()), }, context=context)	def set_function_fields(self, cursor, user, id, name, value, arg, context=None): request_obj = self.pool.get('res.request') req_ref_obj = self.pool.get('res.request.reference')
date = datetime(	date = datetime.datetime(	def add_minutes(self, cursor, user, company, date, minutes, context=None): minutes = int(round(minutes)) minutes = date.minute + minutes
date = datetime(	date = datetime.datetime(	def add_hours(self, cursor, user, company, date, hours, context=None): day_per_week = company.hours_per_work_week / company.hours_per_work_day
date += timedelta(days= -date.weekday() + intfloor(days))	date += datetime.timedelta(days= -date.weekday() + intfloor(days))	def add_days(self, cursor, user, company, date, days, context=None): day_per_week = company.hours_per_work_week / company.hours_per_work_day
date += timedelta(days= 7 * intfloor(weeks))	date += datetime.timedelta(days= 7 * intfloor(weeks))	def add_weeks(self, cursor, user, company, date, weeks, context=None): day_per_week = company.hours_per_work_week / company.hours_per_work_day
cursor = Transation().cursor	cursor = Transaction().cursor	def get_function_fields(self, ids, names): ''' Function to compute function fields
self.assertRaises(Exception, test_view('project_plan'))	test_view('project_plan')	def test0005views(self): ''' Test views. ''' self.assertRaises(Exception, test_view('project_plan'))