def test_basicdump(self):
assert dump(Person()) == {}
assert dump(Person('Alfio')) == {'name': 'Alfio'}
assert dump(Person('Alfio', '33')) == {
'name': 'Alfio',
'address': '33'
}
def test_factory_dump(self):
@attrs
class A:
a = attrib(factory=list, metadata={'ciao': 'ciao'}, type=List[int])
assert dump(A()) == {}
assert dump(A(), hidedefault=False) == {'a': []}
def test_factory_dump(self):
@dataclass
class A:
a: int
b: List[int] = field(default_factory=list)
assert dump(A(3)) == {'a': 3}
assert dump(A(12), hidedefault=False) == {'a': 12, 'b': []}
def test_dump(self):
@dataclass
class A:
a: int
b: int = 0
assert dump(A(12)) == {'a': 12}
assert dump(A(12), hidedefault=False) == {'a': 12, 'b': 0}
def test_weird_mangle(self):
@attrs
class Mangle:
a = attrib(type=int, metadata={'name': 'b', 'alt': 'q'})
b = attrib(type=str, metadata={'name': 'a'})
assert load({'b': 1, 'a': 'ciao'}, Mangle) == Mangle(1, 'ciao')
assert load({
'q': 1,
'b': 'ciao'
}, Mangle, mangle_key='alt') == Mangle(1, 'ciao')
assert dump(Mangle(1, 'ciao')) == {'b': 1, 'a': 'ciao'}
assert dump(Mangle(1, 'ciao'), mangle_key='alt') == {
'q': 1,
'b': 'ciao'
}
def test_norepr(self):
@attrs
class A:
i = attrib(type=int)
j = attrib(type=int, repr=False)
assert dump(A(1, 1)) == {'i': 1}
def test_weird_mangle(self):
@dataclass
class Mangle:
a: int = field(metadata={'name': 'b', 'alt': 'q'})
b: str = field(metadata={'name': 'a'})
assert load({'b': 1, 'a': 'ciao'}, Mangle) == Mangle(1, 'ciao')
assert load({
'q': 1,
'b': 'ciao'
}, Mangle, mangle_key='alt') == Mangle(1, 'ciao')
assert dump(Mangle(1, 'ciao')) == {'b': 1, 'a': 'ciao'}
assert dump(Mangle(1, 'ciao'), mangle_key='alt') == {
'q': 1,
'b': 'ciao'
}
def test_mangle_load(self):
@dataclass
class Mangle:
value: int = field(metadata={'name': 'va.lue'})
assert load({'va.lue': 1}, Mangle) == Mangle(1)
assert dump(Mangle(1)) == {'va.lue': 1}
def test_dump_load_results(self):
results = ExamResults([
(Student('Anna', 1), Result.PASS),
(Student('Alfio', 2), Result.PASS),
(Student('Iano', 3, '*****@*****.**'), Result.PASS),
])
assert load(dump(results), ExamResults) == results
def test_mangle_rename(self):
@attrs
class Mangle:
a = attrib(type=int, metadata={'name': 'b'})
b = attrib(type=str, metadata={'name': 'a'})
assert load({'b': 1, 'a': 'ciao'}, Mangle) == Mangle(1, 'ciao')
assert dump(Mangle(1, 'ciao')) == {'b': 1, 'a': 'ciao'}
def test_mangle_rename(self):
@dataclass
class Mangle:
a: int = field(metadata={'name': 'b'})
b: str = field(metadata={'name': 'a'})
assert load({'b': 1, 'a': 'ciao'}, Mangle) == Mangle(1, 'ciao')
assert dump(Mangle(1, 'ciao')) == {'b': 1, 'a': 'ciao'}
def analyze(so_fname, cache_settings):
"""
Try to find strings and references to them from code in binary file (*.so).
:param so_fname: Path to binary.
:param cache_settings: Instance of CacheSettings.
:return: Dict containing all information required for live-patching.
"""
strs_to_replace = frozenset(
itertools.chain(_REPLACE_DOMAIN.keys(), _REPLACE_REGION.keys()))
# TODO: Use lock file to prevent simultaneous read/write of cache file from
# different threads or processes.
_L.info(f'Reading cache from "{cache_settings.cache_file}"...')
try:
with open(cache_settings.cache_file, 'r') as cache_f:
cache = typedload.load(
json.load(cache_f),
typing.Dict[str, typing.Dict[str, typing.List[r2.BinString]]])
except FileNotFoundError:
cache = {}
_L.debug(f'Calculating sha512("{so_fname}")...')
with open(so_fname, 'rb') as so_f:
so_sha512 = hashlib.sha512(so_f.read()).hexdigest()
_L.info(f'sha512("{so_fname}") == "{so_sha512}"')
if cache_settings.use_cache:
strings = cache.get(so_sha512)
else:
strings = None
if strings is None:
_L.info('Binary not found in cache (slow path)')
strings = r2.find_strings(so_fname, strs_to_replace)
if cache_settings.update_cache:
_L.info(f'Writing cache into "{cache_settings.cache_file}"...')
cache[so_sha512] = strings
cache_file_dir = os.path.dirname(cache_settings.cache_file)
os.makedirs(cache_file_dir, mode=0o700, exist_ok=True)
with atomicwrites.atomic_write(cache_settings.cache_file,
overwrite=True) as cache_f:
json.dump(typedload.dump(cache), cache_f)
else:
_L.info('Using cached values')
n_xrefs = sum(
len(bin_str.xrefs) for bin_strs in strings.values()
for bin_str in bin_strs)
_L.info(f'Found {n_xrefs} references to strings in "{so_fname}"')
_L.debug(f'References: {strings}')
return strings
def save(self, filename: Union[Path, str]) -> None:
'''
Saves the relation in a file.
Will save using the json format
'''
with open(filename, 'w') as fp:
from json import dump as jdump
from typedload import dump
jdump(dump(self), fp)
def test_case(self):
@dataclass
class Mangle:
value: int = field(metadata={'name': 'Value'})
assert load({'Value': 1}, Mangle) == Mangle(1)
assert 'Value' in dump(Mangle(1))
with self.assertRaises(ValueError):
load({'value': 1}, Mangle)
def test_case(self):
@attrs
class Mangle:
value = attrib(type=int, metadata={'name': 'Value'})
assert load({'Value': 1}, Mangle) == Mangle(1)
assert 'Value' in dump(Mangle(1))
with self.assertRaises(TypeError):
load({'value': 1}, Mangle)
def test_ipaddress(self):
assert dump(IPv4Address('10.10.10.1')) == '10.10.10.1'
assert dump(IPv4Network('10.10.10.0/24')) == '10.10.10.0/24'
assert dump(IPv4Interface('10.10.10.1/24')) == '10.10.10.1/24'
assert dump(IPv6Address('fe80::123')) == 'fe80::123'
assert dump(IPv6Network('fe80::/64')) == 'fe80::/64'
assert dump(IPv6Interface('fe80::123/64')) == 'fe80::123/64'
def main() -> None:
""" Make a jazz noise here """
args = get_args()
schema = xmlschema.XMLSchema(args.schema.name)
num_files = len(list(args.files))
print(f'Processing {num_files:,} file{"" if num_files == 1 else "s"}.')
num_written = 0
errors = []
for file in track(args.files, description="Processing..."):
# Determine outfile
basename = os.path.basename(file)
root = os.path.splitext(basename)[0]
out_file = os.path.join(args.outdir, root + '.json')
# print(file)
# Skip existing files
# if os.path.isfile(out_file):
# continue
# Set the "text" to all the distinct words
# xml = xmltodict.parse(open(file).read())
xml = open(file).read()
if not schema.is_valid(xml):
errors.append(f'Invalid document "{file}"')
continue
data = schema.to_dict(xml)
tree = ElementTree().parse(file)
all_text = ' '.join(
set(chain.from_iterable((map(words, flatten(tree))))))
study = restructure(data, all_text)
# pprint(study)
# Convert to JSON
out_fh = open(out_file, 'wt')
out_fh.write(json.dumps(typedload.dump(study), indent=4) + '\n')
out_fh.close()
num_written += 1
if errors:
print('\n'.join([f'{len(errors)} ERRORS:'] + errors), file=sys.stderr)
print(f'Done, wrote {num_written:,} to "{args.outdir}".')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-u',
'--url',
help='The URL that points to the ads.txt',
required=True,
type=str)
args = parser.parse_args()
recursive_parser(args.url, sld=True)
# to json
as_json = typedload.dump(global_state.results)
with open('./output/data.json', 'w') as fh:
json.dump(as_json, fh)
def test_nesteddump(self):
assert dump(
Students('advanced coursing', [
Person('Alfio'),
Person('Carmelo', 'via mulino'),
])) == {
'course':
'advanced coursing',
'students': [
{
'name': 'Alfio'
},
{
'name': 'Carmelo',
'address': 'via mulino'
},
]
}
def diffmsg(self) -> Message:
m = dump(self.current)
m['text'] = seddiff(self.previous.text, self.current.text)
return load(m, Message)
def save_alarm(self):
serialized_alarm = json.dumps(typedload.dump(self.alarm))
with open("alarm.json", "w") as f:
f.write(serialized_alarm)
def get_status(self) -> bytes:
'''
A status string that will be passed back when this is started again
'''
return json.dumps(dump(self._status), ensure_ascii=True).encode('ascii')
def test_kwargs(self):
with self.assertRaises(ValueError):
dump(1, handlers=[])
def test_path(self):
assert dump(Path('/')) == '/'
def test_dump_metanames(self):
assert dump(Mangle(12)) == {'va.lue': 12}
def test_enum(self):
assert load(dump(EnumA.C), EnumA) == EnumA.C
def test_dump(self):
A = NamedTuple('A', [('a', int), ('b', str)])
assert dump(A(1, '12')) == {'a': 1, 'b': '12'}
