def structural(p):
print(len(p))
dataclasses.fields(p)
dataclasses.asdict(p)
dataclasses.astuple(p)
dataclasses.replace(p)
def main():
"""Get Weather Data."""
weather_data = data(get_api_data=True)
current_data = parse_weather_data(weather_data.current)
forecast_data = [asdict(parse_weather_data(data))
for data in weather_data.forecast_daily['list']]
return Weather(current=asdict(current_data),
forecast=forecast_data)
def make_metar_test(station: str):
"""
Builds METAR test files
"""
m = avwx.Metar(station)
m.update()
# Clear timestamp due to parse_date limitations
m.data.time = None
return {
'data': asdict(m.data),
'translations': asdict(m.translations),
'summary': m.summary,
'speech': m.speech,
'station_info': asdict(m.station_info)
}
def test_metar_ete(self):
"""
Performs an end-to-end test of all METAR JSON files
"""
for path in glob(os.path.dirname(os.path.realpath(__file__))+'/metar/*.json'):
ref = json.load(open(path))
station = Metar(path.split('/')[-1][:4])
self.assertIsNone(station.last_updated)
self.assertTrue(station.update(ref['data']['raw']))
self.assertIsInstance(station.last_updated, datetime)
# Clear timestamp due to parse_date limitations
station.data.time = None
self.assertEqual(asdict(station.data), ref['data'])
self.assertEqual(asdict(station.translations), ref['translations'])
self.assertEqual(station.summary, ref['summary'])
self.assertEqual(station.speech, ref['speech'])
self.assertEqual(asdict(station.station_info), ref['station_info'])
def get_dict(self):
ret = asdict(self)
ret.pop('id')
ret.pop('model_root')
ret['start_date'] = ret['start_date'].strftime('%Y-%m-%d')
ret['end_date'] = ret['end_date'].strftime('%Y-%m-%d')
if self.relevant:
ret.pop('relevant')
return ret
async def process_events(app):
while True:
event = await app.event_queue.get()
if app.wss:
msg = asdict(event)
msg['_type'] = type(event).__name__
if 'image' in msg:
msg['image'] = pil_to_data_url(msg['image'], **app.image_encode_settings)
await send_message(app, msg)
def save(self, path: str) -> None:
"""Save a Backlog to a file."""
with open(path, 'w') as backlog_f:
backlog_f.write(
json.dumps(
[dataclasses.asdict(entry) for entry in self.entries],
sort_keys=True,
indent=2,
separators=(',', ': '),
),
)
def make_taf_test(station: str, report: str = None):
"""
Builds TAF test files
"""
t = avwx.Taf(station)
t.update(report)
data = asdict(t.data)
# Clear timestamp due to parse_date limitations
for key in ('time', 'start_time', 'end_time'):
data[key] = None
for i in range(len(data['forecast'])):
for key in ('start_time', 'end_time'):
data['forecast'][i][key] = None
return {
'data': data,
'translations': asdict(t.translations),
'summary': t.summary,
'speech': t.speech,
'station_info': asdict(t.station_info)
}
def test_taf_ete(self):
"""
Performs an end-to-end test of all TAF JSON files
"""
nodate = lambda s: s[s.find('-')+2:]
for path in glob(os.path.dirname(os.path.realpath(__file__))+'/taf/*.json'):
ref = json.load(open(path))
station = Taf(path.split('/')[-1][:4])
self.assertIsNone(station.last_updated)
self.assertTrue(station.update(ref['data']['raw']))
self.assertIsInstance(station.last_updated, datetime)
# Clear timestamp due to parse_date limitations
nodt = deepcopy(station.data)
for key in ('time', 'start_time', 'end_time'):
setattr(nodt, key, None)
for i in range(len(nodt.forecast)):
for key in ('start_time', 'end_time'):
setattr(nodt.forecast[i], key, None)
self.assertEqual(asdict(nodt), ref['data'])
self.assertEqual(asdict(station.translations), ref['translations'])
self.assertEqual(station.summary, ref['summary'])
self.assertEqual(nodate(station.speech), nodate(ref['speech']))
self.assertEqual(asdict(station.station_info), ref['station_info'])
def test_dataframe_to_dataclass():
_df = pd.DataFrame(columns=['field_a', 'field_b'], data=[[1, 'a'], [2, 'b']])
dataclass_objects = [dataclass_object1, dataclass_object2]
df = pd.DataFrame([asdict(x) for x in dataclass_objects])
assert _df.equals(df)
records = df.to_dict(orient='records')
record_objects = [SimpleDataObject(**rec) for rec in records]
assert record_objects == dataclass_objects
def test_dataclass_to_dataframe():
_df = pd.DataFrame(columns=['field_a', 'field_b'], data=[[1, 'a'], [2, 'b']])
dataclass_objects = [dataclass_object1, dataclass_object2]
df = pd.DataFrame([asdict(x) for x in dataclass_objects])
print(df)
""" field_a field_b
0 1 a
1 2 b
"""
assert _df.equals(df)
def get_scholar_json(id):
(agg, papers) = get_scholar_data(id)
dict = {'agg': {}, 'papers': {}}
for key in agg:
dict['agg'][key] = agg[key]
for paper in papers:
dict['papers'][paper.id] = asdict(paper)
json_text = json.dumps(dict, sort_keys=True, indent=4)
json_text = json_text.replace('"agg"', 'agg')
json_text = json_text.replace('"papers"', 'papers')
json_text = json_text.replace('"citations"', 'citations')
json_text = json_text.replace('"id"', 'id')
json_text = json_text.replace('"impact_factor"', 'impact_factor')
json_text = json_text.replace('"is_book"', 'is_book')
json_text = json_text.replace('"is_conference"', 'is_conference')
json_text = json_text.replace('"is_journal"', 'is_journal')
json_text = json_text.replace('"title"', 'title')
return 'var sdata = ' + json_text
def union2(p: Union[Type[A], Type[B]]):
dataclasses.fields(p)
dataclasses.asdict(<warning descr="'dataclasses.asdict' method should be called on dataclass instances">p</warning>)
dataclasses.astuple(<warning descr="'dataclasses.astuple' method should be called on dataclass instances">p</warning>)
dataclasses.replace(<warning descr="'dataclasses.replace' method should be called on dataclass instances">p</warning>)
def dump_malware_scan_request(request: saf.model.EvidenceRequest):
request_dict = dataclasses.asdict(request)
with tempfile.NamedTemporaryFile(delete=False, mode='wt') as tmp_file:
tmp_file.write(json.dumps(request_dict, cls=EnumJSONEncoder))
import dataclasses
from typing import Type, Union
class A:
pass
dataclasses.fields(<warning descr="'dataclasses.fields' method should be called on dataclass instances or types">A</warning>)
dataclasses.fields(<warning descr="'dataclasses.fields' method should be called on dataclass instances or types">A()</warning>)
dataclasses.asdict(<warning descr="'dataclasses.asdict' method should be called on dataclass instances">A()</warning>)
dataclasses.astuple(<warning descr="'dataclasses.astuple' method should be called on dataclass instances">A()</warning>)
dataclasses.replace(<warning descr="'dataclasses.replace' method should be called on dataclass instances">A()</warning>)
@dataclasses.dataclass
class B:
pass
dataclasses.fields(B)
dataclasses.fields(B())
dataclasses.asdict(B())
dataclasses.astuple(B())
dataclasses.replace(B())
dataclasses.asdict(<warning descr="'dataclasses.asdict' method should be called on dataclass instances">B</warning>)
dataclasses.astuple(<warning descr="'dataclasses.astuple' method should be called on dataclass instances">B</warning>)
dataclasses.replace(<warning descr="'dataclasses.replace' method should be called on dataclass instances">B</warning>)
def as_dict(self):
return asdict(self)
def init_db(db_config: DBConfig) -> None:
DATABASE.init(**asdict(db_config))
def to_dict(self) -> dict:
return asdict(self)
def copy_type_with(base: Type,
*types: Type,
params_to_type: Dict[Type, Type] = None) -> Type:
if params_to_type is None:
params_to_type = {}
if isinstance(base, StrawberryUnion):
types = cast(
Tuple[Type, ...],
tuple(
copy_type_with(t, params_to_type=params_to_type)
for t in base.types),
)
return union(
name=get_name_from_types(types),
types=types,
description=base.description,
)
if hasattr(base, "_type_definition"):
definition = cast(TypeDefinition, base._type_definition)
if definition.type_params:
fields = []
type_params = definition.type_params.values()
params_to_type.update(dict(zip(type_params, types)))
name = get_name_from_types(
params_to_type.values()) + definition.name
for field in definition.fields:
kwargs = dataclasses.asdict(field)
if field.is_list:
child = cast(FieldDefinition, field.child)
child_type = cast(Type, child.type)
# TODO: nested list
kwargs["child"] = FieldDefinition(
name=child.name,
origin=child.origin,
origin_name=child.origin_name,
is_optional=child.is_optional,
type=copy_type_with(child_type,
params_to_type=params_to_type),
)
else:
field_type = cast(Type, field.type)
kwargs["type"] = copy_type_with(
field_type, params_to_type=params_to_type)
federation_args = kwargs.pop("federation")
kwargs["federation"] = FederationFieldParams(**federation_args)
fields.append(FieldDefinition(**kwargs))
type_definition = TypeDefinition(
name=name,
is_input=definition.is_input,
origin=definition.origin,
is_interface=definition.is_interface,
is_generic=False,
federation=definition.federation,
interfaces=definition.interfaces,
description=definition.description,
_fields=fields,
)
type_definition._type_params = {}
copied_type = builtins.type(
name,
(),
{"_type_definition": type_definition},
)
if not hasattr(base, "_copies"):
base._copies = {}
base._copies[types] = copied_type
return copied_type
if is_type_var(base):
return params_to_type[base]
return base
if ret is None: # should not happen... but if it does...
print("Unable to locate {} is db.scripts... skipping".format(js_id))
continue
content = ret.get('code')
jsr = JavascriptArtefact(url=hit.get('origin_url'),
sha256=hashlib.sha256(content).hexdigest(),
md5=hashlib.md5(content).hexdigest(),
inline=False)
m, failed, stderr = analyse_script(content, jsr, java=args.java, feature_extractor=args.extractor)
if failed:
n_failed += 1
continue
m.update({ 'origin': hit.get('cited_on'), 'js_id': js_id })
assert 'js_id' in m and len(m['js_id']) > 0 # PRE-CONDITION: ensure hits have origin_js_id field set
best_control, next_best_control = find_best_control(m, all_controls, db=db)
d = asdict(best_control) # NB: all fields of the model are sent to output kafka topic and Mongo
# 2a. also send results to MongoDB for batch-oriented applications and for long-term storage
# POST-CONDITIONS which MUST be maintained are checked before pushing to topic
assert 'cited_on' in d and len(d['cited_on']) > 0
assert 'origin_url' in d and len(d['origin_url']) > 0
assert isinstance(d['origin_js_id'], str) or d['origin_js_id'] is None
ret = db.vet_against_control.find_one_and_update({ 'origin_url': best_control.origin_url },
{ "$set": d},
upsert=True,
return_document=pymongo.ReturnDocument.AFTER)
# 2b. send results to kafka topic for streaming applications
assert ret is not None and '_id' in ret
xref = str(ret.get('_id'))
assert xref is not None
def register_bot(authentication_code: str, bot: Bot):
"""
Register bot to the system.
"""
get_db().hmset(f'registration.{authentication_code}', asdict(bot))
def serialize(self) -> Dict[str, Any]:
return dataclasses.asdict(self)
def test_compute_model_dependencies(
self,
mock_expand,
mock_project,
mock_inverse_utility,
mock_affine_model,
mock_Acquisition_compute,
):
# TODO: Patch only `MFKG_PATH.__init__` once `construct_inputs`
# implemented for qMFKG.
with patch(
f"{MULTI_FIDELITY_PATH}.MultiFidelityAcquisition.__init__",
return_value=None,
):
# We don't actually need to instantiate the BoTorch acqf in these tests.
mf_acquisition = MultiFidelityAcquisition(
surrogate=self.surrogate,
search_space_digest=self.search_space_digest,
objective_weights=self.objective_weights,
botorch_acqf_class=qMultiFidelityKnowledgeGradient,
)
# Raise Error if `fidelity_weights` and `target_fidelities` do not align.
with self.assertRaisesRegex(RuntimeError, "Must provide the same indices"):
mf_acquisition.compute_model_dependencies(
surrogate=self.surrogate,
search_space_digest=SearchSpaceDigest(
**{
**dataclasses.asdict(self.search_space_digest),
"target_fidelities": {1: 5.0},
}
),
objective_weights=self.objective_weights,
pending_observations=self.pending_observations,
outcome_constraints=self.outcome_constraints,
linear_constraints=self.linear_constraints,
fixed_features=self.fixed_features,
options=self.options,
)
# Make sure `fidelity_weights` are set when they are not passed in.
mf_acquisition.compute_model_dependencies(
surrogate=self.surrogate,
search_space_digest=SearchSpaceDigest(
**{
**dataclasses.asdict(self.search_space_digest),
"target_fidelities": {2: 5.0, 3: 5.0},
}
),
objective_weights=self.objective_weights,
pending_observations=self.pending_observations,
outcome_constraints=self.outcome_constraints,
linear_constraints=self.linear_constraints,
fixed_features=self.fixed_features,
options={Keys.COST_INTERCEPT: 1.0, Keys.NUM_TRACE_OBSERVATIONS: 0},
)
mock_affine_model.assert_called_with(
fidelity_weights={2: 1.0, 3: 1.0}, fixed_cost=1.0
)
# Usual case.
dependencies = mf_acquisition.compute_model_dependencies(
surrogate=self.surrogate,
search_space_digest=self.search_space_digest,
objective_weights=self.objective_weights,
pending_observations=self.pending_observations,
outcome_constraints=self.outcome_constraints,
linear_constraints=self.linear_constraints,
fixed_features=self.fixed_features,
options=self.options,
)
mock_Acquisition_compute.assert_called_with(
surrogate=self.surrogate,
search_space_digest=self.search_space_digest,
objective_weights=self.objective_weights,
pending_observations=self.pending_observations,
outcome_constraints=self.outcome_constraints,
linear_constraints=self.linear_constraints,
fixed_features=self.fixed_features,
options=self.options,
)
mock_affine_model.assert_called_with(
fidelity_weights=self.options[Keys.FIDELITY_WEIGHTS],
fixed_cost=self.options[Keys.COST_INTERCEPT],
)
mock_inverse_utility.assert_called_with(cost_model="cost_model")
self.assertTrue(Keys.COST_AWARE_UTILITY in dependencies)
self.assertTrue(Keys.PROJECT in dependencies)
self.assertTrue(Keys.EXPAND in dependencies)
# Check that `project` and `expand` are defined correctly.
project = dependencies.get(Keys.PROJECT)
project(torch.tensor([1.0]))
mock_project.assert_called_with(
X=torch.tensor([1.0]),
target_fidelities=self.search_space_digest.target_fidelities,
)
expand = dependencies.get(Keys.EXPAND)
expand(torch.tensor([1.0]))
mock_expand.assert_called_with(
X=torch.tensor([1.0]),
fidelity_dims=sorted(self.search_space_digest.target_fidelities),
num_trace_obs=self.options.get(Keys.NUM_TRACE_OBSERVATIONS),
)
def save_to_json(self, json_path: str):
""" Save the content of this instance in JSON format inside :obj:`json_path`."""
json_string = json.dumps(
dataclasses.asdict(self), indent=2, sort_keys=True) + "\n"
with open(json_path, "w", encoding="utf-8") as f:
f.write(json_string)
def default(self, o):
if dataclasses.is_dataclass(o):
return dataclasses.asdict(o)
if isinstance(o, Path):
return str(o)
return super().default(o)
def as_dict(self) -> Dict[str, Any]:
return dataclasses.asdict(self)
def get(self, iden):
rule = self._rules.get(iden)
if rule is None:
raise s_exc.NoSuchIden()
return dataclasses.asdict(rule)
@dataclass(order=True)
class Employee:
first: str = field(compare=False)
last: str = field(compare=False)
pay: int
fullname: str = field(init=False, repr=False, compare=False)
email: str = field(init=False, repr=False, compare=False)
def __post_init__(self):
self.fullname = self.first + self.last
self.email = self.first + "." + self.last + "@company.com"
e1 = Employee("indhu", "mathy", 500)
e2 = Employee("karthi", "palani", 1000)
print(e1)
print(e1 > e2)
print(e1 == e2)
print(e1.fullname)
print(e1.email)
emp_dict = e1.__dict__
print(emp_dict)
print(asdict(e1))
# converting object to json
import json
jdata = json.dumps(emp_dict, indent=2)
print(jdata)
def tojson(self) -> str:
return json.dumps(asdict(self))
def to_json(self):
"""Return the json representation of the class."""
return json.dumps(dataclasses.asdict(self))
def test_find_success(self, data, repo: Repository, dao: IDao):
id_ = dao.insert(**data)
entity = repo.find(id_)
assert isinstance(entity, Bike)
assert dataclasses.asdict(entity) == data
def __init__(self):
super().__init__()
self.config = Config(**dataclasses.asdict(main_thread_config))
def _property_to_dict(self, advertised: AdvertisedProperty) -> Dict:
as_dict = asdict(advertised)
as_dict.pop('property_id', None)
return as_dict
def push(self, name: str, data: Data) -> Intent:
# TODO check stack size overflow and data overflow
intent = Intent(id_to_str(new_id()), name, data)
self._stack().append(asdict(intent))
return intent
from dataclasses import dataclass, asdict
from typing import List
@dataclass
class Point:
x: int
y: int
@dataclass
class C:
z: List[Point]
p = Point(10, 20)
assert asdict(p) == {'x': 10, 'y': 20}
c = C([Point(0, 0), Point(10, 4)])
assert asdict(c) == {'z': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}
def serialize(self):
"""Serializes the ClickEvent for sending to Kafka"""
out = BytesIO()
writer(out, ClickEvent.schema, [asdict(self)])
return out.getvalue()
def unknown(p):
dataclasses.fields(p)
dataclasses.asdict(p)
dataclasses.astuple(p)
def asdict(self) -> Dict[str, float]:
"""Converts parameters to a dictionary that maps angle names to values."""
return dataclasses.asdict(self)
def union1(p: Union[A, B]):
dataclasses.fields(p)
dataclasses.asdict(p)
dataclasses.astuple(p)
dataclasses.replace(p)
def wrap_vault(vault: Union[VaultV1, VaultV2], samples: ApySamples,
aliases: dict, icon_url: str, assets_metadata: dict) -> dict:
apy_error = Apy("error", 0, 0, ApyFees(0, 0), ApyPoints(0, 0, 0))
try:
apy = vault.apy(samples)
except ValueError as error:
logger.error(error)
apy = apy_error
except PriceError as error:
logger.error(error)
apy = apy_error
if isinstance(vault, VaultV1):
strategies = [{
"address":
str(vault.strategy),
"name":
vault.strategy.getName()
if hasattr(vault.strategy, "getName") else vault.strategy._name,
}]
else:
strategies = [{
"address": str(strategy.strategy),
"name": strategy.name
} for strategy in vault.strategies]
inception = contract_creation_block(str(vault.vault))
token_alias = aliases[str(vault.token)]["symbol"] if str(
vault.token) in aliases else vault.token.symbol()
vault_alias = token_alias
tvl = vault.tvl()
migration = None
if str(vault.vault) in assets_metadata:
migration = {
"available": assets_metadata[str(vault.vault)][1],
"address": assets_metadata[str(vault.vault)][2]
}
object = {
"inception":
inception,
"address":
str(vault.vault),
"symbol":
vault.symbol if hasattr(vault, "symbol") else vault.vault.symbol(),
"name":
vault.name,
"display_name":
vault_alias,
"icon":
icon_url % str(vault.vault),
"token": {
"name":
vault.token.name()
if hasattr(vault.token, "name") else vault.token._name,
"symbol":
vault.token.symbol() if hasattr(vault.token, "symbol") else None,
"address":
str(vault.token),
"decimals":
vault.token.decimals()
if hasattr(vault.token, "decimals") else None,
"display_name":
token_alias,
"icon":
icon_url % str(vault.token),
},
"tvl":
dataclasses.asdict(tvl),
"apy":
dataclasses.asdict(apy),
"strategies":
strategies,
"endorsed":
vault.is_endorsed if hasattr(vault, "is_endorsed") else True,
"version":
vault.api_version if hasattr(vault, "api_version") else "0.1",
"decimals":
vault.decimals
if hasattr(vault, "decimals") else vault.vault.decimals(),
"type":
"v2" if isinstance(vault, VaultV2) else "v1",
"emergency_shutdown":
vault.vault.emergencyShutdown()
if hasattr(vault.vault, "emergencyShutdown") else False,
"updated":
int(time()),
"migration":
migration,
}
if chain.id == 1 and any(
[isinstance(vault, t) for t in [Backscratcher, YveCRVJar]]):
object["special"] = True
return object
def construct_json(self) -> Dict:
"""Construct dictionary/JSON for exporting or printing.
:return json_out: All class attributes stored in a dictionary.
"""
return asdict(self)
assessment_as_worker: float # None or 0.0 - 5.0
assessment_as_employer: float # None or 0.0 - 5.0
def __init__(self, dictionary):
"""
Конструктор через словарь
"""
for key in dictionary:
setattr(self, key, dictionary[key])
if __name__ == "__main__":
dict_to_User = {
'vkid': 'id',
'type': 'Admin',
'employer_rating': 0.2,
'worker_rating': 1,
'status': 'Silver',
'is_blocked': 1
}
print("dict to User: "******"type", "Admin")
print("User from dict: ", User_from_dict)
# User -> dict
dict_from_User = asdict(User_from_dict)
print("dict from User:", dict_from_User)
def list(self):
return [(iden, dataclasses.asdict(rule)) for iden, rule in self._rules.items()]
def asDict(self):
user_as_dict = dict()
for k, v in asdict(self).items():
user_as_dict[k[1:]] = v
return user_as_dict
def en(self):
return s_msgpack.en(dataclasses.asdict(self))
def add_game(self, game: str, long_name: str, role_id: int, emoji: int, category_id: int, cog: str = None):
""" Adds a new game to the bot """
# The asdict prevents one from create a dict that is invalid to Game
self.__games[game] = dataclasses.asdict(Game(name_short=game, name_long=long_name, role_id=role_id, emoji=emoji, category_id=category_id, cog=cog))
def as_dict(self) -> dict:
return dataclasses.asdict(self)
def test_parser_mutation(self):
query = """
mutation CreateHero {
createHero {
hero {
name
}
ok
}
}
"""
parser = QueryParser(self.swapi_schema)
parsed = parser.parse(query)
expected = asdict(
ParsedQuery(
query=query,
objects=[
ParsedOperation(
name="CreateHero",
type="mutation",
children=[
ParsedObject(
name="CreateHeroData",
fields=[
ParsedField(
name="createHero",
type="CreateHeroPayload",
nullable=True,
)
],
children=[
ParsedObject(
name="CreateHeroPayload",
fields=[
ParsedField(name="hero",
type="Hero",
nullable=True),
ParsedField(name="ok",
type="bool",
nullable=True),
],
children=[
ParsedObject(
name="Hero",
fields=[
ParsedField(
name="name",
type="str",
nullable=False,
)
],
)
],
)
],
)
],
)
],
))
parsed_dict = asdict(parsed)
assert bool(parsed)
assert parsed_dict == expected, str(DeepDiff(parsed_dict, expected))
def _custom_default(o):
if is_dataclass(o):
return asdict(o)
raise TypeError(f"{o!r} is not JSON serializable")
def write(data, *args, **kwargs):
"""Write data to the json file."""
with open('game_on.json', 'w') as json_file:
json.dump(data, json_file)
return True
def main():
"""Game on main funtion."""
pass
if __name__ == "__main__":
if not len(sys.argv) < 1:
exit(0)
match = Match('Name') # -g "Name"
p1 = Player('Player 1') # -p1 "Name"
p2 = Player('Player 2') # -p1 "Name"
r1 = Results(match, p1, 2) # -r1 2
r2 = Results(match, p2, 12) # -r2 2
r1.losses = r2.wins
r2.losses = r1.wins
data = {}
data['result'] = [asdict(r1), asdict(r2)]
def to_session_dict(self):
return asdict(self)
def save_to_file(self, config_path):
with open(config_path, 'w') as config_file:
json.dump(dataclasses.asdict(self), config_file, indent=2, sort_keys=True)
def fill_info_from_seq_region_raw(self,
raw_json: Optional[str],
add_missing: bool = True,
use_syns: bool = True,
update_from_new: bool = True,
update_syns: bool = True) -> None:
if not raw_json:
return
_open = raw_json.endswith(".gz") and gzip.open or open
with _open(raw_json, 'rt') as sr_raw:
print("adding data from seq_regions json:",
raw_json,
file=sys.stderr)
data = json.load(sr_raw, object_pairs_hook=OrderedDict)
if type(data) != list:
data = [data]
for sr in data:
name = sr.get("name")
if not name:
continue
contig = name
if use_syns and contig not in self.seq_regions:
contig = self.syns.get(contig, contig)
if not add_missing and contig not in self.seq_regions:
continue
# updating othewise
sr_dict = dc.asdict(self.seq_regions[contig],
dict_factory=no_nulls_dict)
updates = {}
tags_to_copy_str = "length coord_system_level location circular codon_table karyotype_bands"
for tag in tags_to_copy_str.split():
val = sr.get(tag)
if val is None: continue
if not val: continue
if not update_from_new and sr_dict.get(tag) is not None:
continue
updates[tag] = val
# update karyotype_bands coloring
#sorted([(0,3), (1,2), (2,3)], key = lambda x:(x[1],-x[0])) == [(1, 2), (2, 3), (0, 3)]
bands_start_sorted = sorted(updates.get("karyotype_bands", []),
key=lambda x:
(x["end"], -x["start"]))
prev, band_no = None, 0
for band in bands_start_sorted:
if band.get("stain"):
continue # don't increase band_no or change prev
if prev and band["start"] <= prev["start"]:
continue # same for "metaband"
band["stain"] = band_no and "gpos75" or "gpos25"
prev, band_no = band, (band_no + 1) % 2
# synonyms
raw_syns = sr.get("synonyms")
if update_syns and raw_syns:
old_syns = self.seq_regions[contig].synonyms
raw_syns = [
SeqRegionSyn(s["name"],
s.get("source", self.syn_src_default))
for s in raw_syns
]
updates["synonyms"] = self.merge_syns(old_syns,
raw_syns,
use_new_source=True)
# update
self.seq_regions[contig] = dc.replace(self.seq_regions[contig],
**updates)
return
def asdict(self) -> Dict[str, Union[str, Optional[str]]]:
"""Dictionary representation used to pass information to JS code."""
return {k: v for k, v in asdict(self).items() if not k.startswith('_')}
def test_kom_happy_path():
"""
Test Komer object class
"""
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
def __iter__(self):
return iter(asdict(self))
jim = Record(first="Jim",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
jimser = json.dumps(asdict(jim)).encode("utf-8")
jim = helping.datify(Record, json.loads(bytes(jimser).decode("utf-8")))
assert isinstance(jim, Record)
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
mydb = koming.Komer(db=db, schema=Record, subkey='records.')
assert isinstance(mydb, koming.Komer)
sue = Record(first="Susan",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(keys=keys)
assert actual.first == "Susan"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
mydb.rem(keys)
actual = mydb.get(keys=keys)
assert actual is None
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(keys=keys)
assert actual == sue
kip = Record(first="Kip",
last="Thorne",
street="200 Center Street",
city="Bluffdale",
state="UT",
zip=84043)
result = mydb.put(keys=keys, data=kip)
assert not result
actual = mydb.get(keys=keys)
assert actual == sue
result = mydb.pin(keys=keys, data=kip)
assert result
actual = mydb.get(keys=keys)
assert actual == kip
# test with keys as string not tuple
keys = "keystr"
bob = Record(first="Bob",
last="Brown",
street="100 Center Street",
city="Bluffdale",
state="UT",
zip=84043)
mydb.put(keys=keys, data=bob)
actual = mydb.get(keys=keys)
assert actual.first == "Bob"
assert actual.last == "Brown"
assert actual.street == "100 Center Street"
assert actual.city == "Bluffdale"
assert actual.state == "UT"
assert actual.zip == 84043
mydb.rem(keys)
actual = mydb.get(keys=keys)
assert actual is None
assert not os.path.exists(db.path)
assert not db.opened
def get_args_dict(self):
args = dataclasses.asdict(self.args)
args["scenario_id"] = self.id
return args
def __iter__(self):
return iter(asdict(self))
def test_parser_query_with_enums(self):
query = """
query MyIssues {
viewer {
issues(first: 5) {
edges {
node {
author { login }
authorAssociation
}
}
}
}
}
"""
parsed = self.github_parser.parse(query)
issue_child = ParsedObject(
name="Issue",
fields=[
ParsedField(name="author", type="Actor", nullable=True),
ParsedField(
name="authorAssociation",
type="CommentAuthorAssociation",
nullable=False,
),
],
children=[
ParsedObject(
name="Actor",
fields=[
ParsedField(name="login", type="str", nullable=False)
],
)
],
)
child = ParsedObject(
name="MyIssuesData",
fields=[ParsedField(name="viewer", type="User", nullable=False)],
children=[
ParsedObject(
name="User",
fields=[
ParsedField(name="issues",
type="IssueConnection",
nullable=False)
],
children=[
ParsedObject(
name="IssueConnection",
fields=[
ParsedField(name="edges",
type="List[IssueEdge]",
nullable=True)
],
children=[
ParsedObject(
name="IssueEdge",
fields=[
ParsedField(name="node",
type="Issue",
nullable=True)
],
children=[issue_child],
)
],
)
],
)
],
)
expected = asdict(
ParsedQuery(
query=query,
enums=[
ParsedEnum(
name="CommentAuthorAssociation",
values={
"MEMBER": "MEMBER",
"OWNER": "OWNER",
"COLLABORATOR": "COLLABORATOR",
"CONTRIBUTOR": "CONTRIBUTOR",
"FIRST_TIME_CONTRIBUTOR": "FIRST_TIME_CONTRIBUTOR",
"FIRST_TIMER": "FIRST_TIMER",
"NONE": "NONE",
},
)
],
objects=[
ParsedOperation(name="MyIssues",
type="query",
children=[child])
],
))
parsed_dict = asdict(parsed)
assert bool(parsed)
assert parsed_dict == expected, str(DeepDiff(parsed_dict, expected))
