def parseRPMSpec(fileName: Path):
spec = parseSpec(fileName)
pkgs = {}
metadataFields = (
'group',
'license',
'name',
'summary',
'url',
'epoch',
'release',
)
relationsGroups = ('obsoletes', 'requires', 'conflicts', 'provides',
'build_requires')
packages = [spec] + spec.packages
for p in packages:
pkgRef = RPMBased.toPackageRefWithGroupResolved(p.name)
try:
pkgRef = pkgRef.clone(cls=VersionedPkgRef,
version=AnyVer(p.version))
except:
pass
p.version = None
metadata = PackageMetadata(pkgRef)
for rgName in relationsGroups:
processRelationGroup(rgName, metadata.controlDict, p)
for nm in metadataFields:
if hasattr(p, nm):
metadata.controlDict[nm] = getattr(p, nm)
pkgs[metadata] = makeTearingSpec(pkgRef, p)
return {"source": None, "pkgs": tuple(pkgs.items())}
def processRelationGroup(grpName, metadata, spec):
src = getattr(spec, grpName)
res = []
for pkgDepSpc in src:
rn = pkgDepSpc.name
m = funcNameRx.match(rn)
if m:
funcN, args = m.groups()
print(funcN, args)
args = tuple(a.strip() for a in args.split(","))
refs = funcsRemap[funcN](*args)
refs = [
nativeDistro.toPackageRefWithGroupResolved(rn) for r in refs
]
else:
refs = (RPMBased.toPackageRefWithGroupResolved(rn), )
for ref in refs:
if pkgDepSpc.version:
ref = PackageRef.clone(ref,
cls=VersionedPackageRef,
version=AnyVer(pkgDepSpc.version))
#print(pkgDepSpc, ref)
res.append(ref)
metadata[grpName] = set(res)
def __call__(self):
return 1, (FilesPackageMapping(
VersionedPackageRef("sqlite3",
arch="amd64",
version=AnyVer("3.29.0")),
[Path("/usr/bin/sqlite3")]),
FilesPackageMapping(
BasePackageRef("ffsgsfsf", arch="amd64"),
[Path("/ffsgsfsf/ffsgsfsf/ffsgsfsf")]))
def testEditing(self) -> None:
a = AnyVer("0-1.2 3-F2BFA")
b = _AnyVer(array('B', (1, 2, 3, 4)),
hash="F2BFA",
format="{0}-{1}.{2} {3}")
for i in range(4):
a[i] += 1
self.assertEqual(a, b)
self.assertEqual(str(a), str(b))
def testRepr(self) -> None:
self.assertEqual(
repr(
_AnyVer(array('H', (2019, 10, 16)),
hash="F2BFA",
format="{0}-{1}-{2}",
suffixFormat=" {hash}")),
"_AnyVer(array('H', [2019, 10, 16]), 'F2BFA', format='{0}-{1}-{2}', suffixFormat=' {hash}')"
)
self.assertEqual(repr(AnyVer("2019-10-16 F2BFA")),
"AnyVer('2019-10-16 F2BFA')")
def packagesMappingYielder(self, pkgs):
index = {pkg['Package'].text: AnyVer(pkg['Version'].text) for pkg in readStatusFile() if 'Version' in pkg}
for p in pkgs:
nameArch = p.stem.split(":")
if len(nameArch) != 1:
name, arch = nameArch
else:
name = nameArch[0]
arch = self.defaultArch
if name in index:
ref = interfaces.VersionedPackageRef(name, arch, version=index[name])
else:
ref = interfaces.BasePackageRef(name, arch)
yield interfaces.FilesPackageMapping(ref, self.__class__.filesYielder(p))
def testOperation(self):
cacheDBPath = thisDir / "package2fileCache.sqlite"
if cacheDBPath.exists():
cacheDBPath.unlink()
with File2Package(ExamplePackagePopulator(),
cacheDB=cacheDBPath) as f2p:
etalonRef = VersionedPackageRef("sqlite3",
arch="amd64",
version=AnyVer("3.29.0"))
self.assertEqual(f2p[Path("/usr/bin/sqlite3")], etalonRef)
self.assertEqual(f2p[etalonRef], etalonRef)
self.assertEqual(f2p[etalonRef.clone(cls=PackageRef)], etalonRef)
self.assertEqual(f2p[etalonRef.clone(cls=BasePackageRef)],
etalonRef)
self.assertEqual(f2p[Path("/ffsgsfsf/ffsgsfsf/ffsgsfsf")],
BasePackageRef("ffsgsfsf", arch="amd64"))
def testNamedComponents(self) -> None:
a = AnyVer("0-1.2 3-F2BFA")
self.assertEqual(a.major, 0)
self.assertEqual(a.minor, 1)
self.assertEqual(a.patch, 2)
self.assertEqual(a.tweak, 3)
a.major = 3
a.minor = 2
a.patch = 1
a.tweak = 0
self.assertEqual(tuple(a), (3, 2, 1, 0))
def testResolver(self):
with File2Package("dpkg") as d:
pr = psutil.Process()
for m in pr.memory_maps():
if m.path and m.path[0] == "/":
p = Path(m.path)
etalon = None
try:
res = dpkgS(p)
except:
continue
res = res.rsplit(':', 1)[0].strip().split(":")
if len(res) ==1:
res.append(defaultArch)
etalon = BasePackageRef(*res)
res2 = debParse(data=str(dpkgs(etalon.name)))
pkg = res2.packages[0]
if "Version" in pkg:
etalon = etalon.clone(cls=VersionedPackageRef, version=AnyVer(pkg["Version"].text))
with self.subTest(etalon=etalon, path=p):
ourP = d[p]
self.assertEqual(ourP, etalon)
def testHashability(self) -> None:
for (c, (parsingDict, r)) in self.__class__.pairs.items():
with self.subTest(c=c, r=r):
p = AnyVer(c)
self.assertEqual(hash(p), hash(r))
def testLt(self):
self.assertLess(AnyVer("2019-10-16 F2BFA"), AnyVer("2019-10-17 F2BFA"))
def testCloning(self) -> None:
a = AnyVer("0-1.2 3-F2BFA")
b = AnyVer(a)
self.assertEqual(a, b)
def testIdentities(self) -> None:
for (c, (parsingDict, r)) in self.__class__.pairs.items():
with self.subTest(c=c, r=r):
p = AnyVer(c)
self.assertEqual(p, r)
self.assertEqual(p.suffixFormat, r.suffixFormat)
def testUnparseableVersion(self) -> None:
with self.assertRaises(ValueError):
AnyVer("fffffuuuu")
def testTypeCheck(self) -> None:
with self.assertRaises(ValueError):
AnyVer(None)
def testGt(self):
self.assertGreater(AnyVer("2019-10-17 F2BFA"),
AnyVer("2019-10-16 F2BFA"))
def testRoundTrip(self) -> None:
for (c, (parsingDict, r)) in self.__class__.pairs.items():
with self.subTest(c=c, r=r):
self.assertEqual(str(AnyVer(c)), c)
