text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_name(self, name):
"""Writes a domain name to the packet""" |
try:
# Find existing instance of this name in packet
#
index = self.names[name]
except KeyError:
# No record of this name already, so write it
# out as normal, recording the location of the name
# for future pointers to it.
#
self.names[name] = self.size
parts = name.split('.')
if parts[-1] == '':
parts = parts[:-1]
for part in parts:
self.write_utf(part)
self.write_byte(0)
return
# An index was found, so write a pointer to it
#
self.write_byte((index >> 8) | 0xC0)
self.write_byte(index) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_question(self, question):
"""Writes a question to the packet""" |
self.write_name(question.name)
self.write_short(question.type)
self.write_short(question.clazz) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet(self):
"""Returns a string containing the packet's bytes No further parts should be added to the packet once this is done.""" |
if not self.finished:
self.finished = 1
for question in self.questions:
self.write_question(question)
for answer, time in self.answers:
self.write_record(answer, time)
for authority in self.authorities:
self.write_record(authority, 0)
for additional in self.additionals:
self.write_record(additional, 0)
self.insert_short(0, len(self.additionals))
self.insert_short(0, len(self.authorities))
self.insert_short(0, len(self.answers))
self.insert_short(0, len(self.questions))
self.insert_short(0, self.flags)
if self.multicast:
self.insert_short(0, 0)
else:
self.insert_short(0, self.id)
return b''.join(self.data) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add(self, entry):
"""Adds an entry""" |
if self.get(entry) is not None:
return
try:
list = self.cache[entry.key]
except:
list = self.cache[entry.key] = []
list.append(entry) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sign(self, entry, signer=None):
"""Adds and sign an entry""" |
if (self.get(entry) is not None):
return
if (entry.rrsig is None) and (self.private is not None):
entry.rrsig = DNSSignatureS(entry.name,
_TYPE_RRSIG, _CLASS_IN, entry, self.private, signer)
self.add(entry)
if (self.private is not None):
self.add(entry.rrsig) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove(self, entry):
"""Removes an entry""" |
try:
list = self.cache[entry.key]
list.remove(entry)
except:
pass |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get(self, entry):
"""Gets an entry by key. Will return None if there is no matching entry.""" |
try:
list = self.cache[entry.key]
return list[list.index(entry)]
except:
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_by_details(self, name, type, clazz):
"""Gets an entry by details. Will return None if there is no matching entry.""" |
entry = DNSEntry(name, type, clazz)
return self.get(entry) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def entries(self):
"""Returns a list of all entries""" |
def add(x, y):
return x + y
try:
return reduce(add, list(self.cache.values()))
except:
return [] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_record(self, zeroconf, now, record):
"""Callback invoked by Zeroconf when new information arrives. Updates information required by browser in the Zeroconf cache.""" |
if record.type == _TYPE_PTR and record.name == self.type:
expired = record.is_expired(now)
try:
oldrecord = self.services[record.alias.lower()]
if not expired:
oldrecord.reset_ttl(record)
else:
del(self.services[record.alias.lower()])
callback = lambda x: self.listener.remove_service(x,
self.type, record.alias)
self.list.append(callback)
return
except:
if not expired:
self.services[record.alias.lower()] = record
callback = lambda x: self.listener.add_service(x,
self.type, record.alias)
self.list.append(callback)
expires = record.get_expiration_time(75)
if expires < self.next_time:
self.next_time = expires |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_properties(self, properties):
"""Sets properties and text of this info from a dictionary""" |
if isinstance(properties, dict):
self.properties = properties
self.sync_properties()
else:
self.text = properties |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_text(self, text):
"""Sets properties and text given a text field""" |
self.text = text
try:
self.properties = text_to_dict(text)
except:
traceback.print_exc()
self.properties = None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_record(self, zeroconf, now, record):
"""Updates service information from a DNS record""" |
if record is not None and not record.is_expired(now):
if record.type == _TYPE_A:
if record.name == self.name:
if not record.address in self.address:
self.address.append(record.address)
elif record.type == _TYPE_SRV:
if record.name == self.name:
self.server = record.server
self.port = record.port
self.weight = record.weight
self.priority = record.priority
self.address = []
self.update_record(zeroconf, now,
zeroconf.cache.get_by_details(self.server,
_TYPE_A, _CLASS_IN))
elif record.type == _TYPE_TXT:
if record.name == self.name:
self.set_text(record.text) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def request(self, zeroconf, timeout):
"""Returns true if the service could be discovered on the network, and updates this object with details discovered. """ |
now = current_time_millis()
delay = _LISTENER_TIME
next = now + delay
last = now + timeout
result = 0
try:
zeroconf.add_listener(self,
DNSQuestion(self.name, _TYPE_ANY, _CLASS_IN))
while self.server is None or \
len(self.address) == 0 or \
self.text is None:
if last <= now:
return 0
if next <= now:
out = DNSOutgoing(_FLAGS_QR_QUERY)
out.add_question(DNSQuestion(self.name,
_TYPE_SRV, _CLASS_IN))
out.add_answer_at_time(
zeroconf.cache.get_by_details(self.name,
_TYPE_SRV, _CLASS_IN), now)
out.add_question(
DNSQuestion(self.name, _TYPE_TXT, _CLASS_IN))
out.add_answer_at_time(
zeroconf.cache.get_by_details(self.name,
_TYPE_TXT, _CLASS_IN), now)
if self.server is not None:
out.add_question(
DNSQuestion(self.server, _TYPE_A, _CLASS_IN))
out.add_answer_at_time(
zeroconf.cache.get_by_details(self.server,
_TYPE_A, _CLASS_IN), now)
zeroconf.send(out)
next = now + delay
delay = delay * 2
zeroconf.wait(min(next, last) - now)
now = current_time_millis()
result = 1
finally:
zeroconf.remove_listener(self)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait(self, timeout):
"""Calling thread waits for a given number of milliseconds or until notified.""" |
self.condition.acquire()
self.condition.wait(timeout // 1000)
self.condition.release() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def notify_all(self):
"""Notifies all waiting threads""" |
self.condition.acquire()
# python 3.x
try:
self.condition.notify_all()
except:
self.condition.notifyAll()
self.condition.release() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_service_info(self, type, name, timeout=3000):
"""Returns network's service information for a particular name and type, or None if no service matches by the timeout, which defaults to 3 seconds.""" |
info = ServiceInfo(type, name)
if info.request(self, timeout):
return info
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_serviceListener(self, type, listener):
"""Adds a listener for a particular service type. This object will then have its update_record method called when information arrives for that type.""" |
self.remove_service_listener(listener)
self.browsers.append(ServiceBrowser(self, type, listener)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_service_listener(self, listener):
"""Removes a listener from the set that is currently listening.""" |
for browser in self.browsers:
if browser.listener == listener:
browser.cancel()
del(browser) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def register_service(self, info):
"""Registers service information to the network with a default TTL of 60 seconds. Zeroconf will then respond to requests for information for that service. The name of the service may be changed if needed to make it unique on the network.""" |
self.check_service(info)
self.services[info.name.lower()] = info
# zone transfer
self.transfer_zone(info.type)
self.announce_service(info.name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def unregister_service(self, info):
"""Unregister a service.""" |
try:
del(self.services[info.name.lower()])
except:
pass
now = current_time_millis()
next_time = now
i = 0
while i < 3:
if now < next_time:
self.wait(next_time - now)
now = current_time_millis()
continue
out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
out.add_answer_at_time(
DNSPointer(info.type,
_TYPE_PTR, _CLASS_IN, 0, info.name), 0)
out.add_answer_at_time(
DNSService(info.name,
_TYPE_SRV, _CLASS_IN, 0, info.priority,
info.weight, info.port, info.name), 0)
out.add_answer_at_time(
DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
for k in info.address:
out.add_answer_at_time(
DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, k), 0)
self.send(out)
i += 1
next_time += _UNREGISTER_TIME |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_service(self, info):
"""Checks the network for a unique service name, modifying the ServiceInfo passed in if it is not unique.""" |
now = current_time_millis()
next_time = now
i = 0
while i < 3:
for record in self.cache.entries_with_name(info.type):
if record.type == _TYPE_PTR and \
not record.is_expired(now) and \
record.alias == info.name:
if (info.name.find('.') < 0):
info.name = info.name + ".[" + \
info.address + \
":" + info.port + \
"]." + info.type
self.check_service(info)
return
raise NonUniqueNameException
if now < next_time:
self.wait(next_time - now)
now = current_time_millis()
continue
out = DNSOutgoing(_FLAGS_QR_QUERY | _FLAGS_AA)
self.debug = out
out.add_question(
DNSQuestion(info.type, _TYPE_PTR, _CLASS_IN))
out.add_authorative_answer(
DNSPointer(info.type,
_TYPE_PTR, _CLASS_IN, info.ttl, info.name))
self.send(out)
i += 1
next_time += _CHECK_TIME |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_listener(self, listener, question):
"""Adds a listener for a given question. The listener will have its update_record method called when information is available to answer the question.""" |
now = current_time_millis()
self.listeners.append(listener)
if question is not None:
for record in self.cache.entries_with_name(question.name):
if question.answered_by(record) and not record.is_expired(now):
listener.update_record(self, now, record)
self.notify_all() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_record(self, now, rec):
"""Used to notify listeners of new information that has updated a record.""" |
for listener in self.listeners:
listener.update_record(self, now, rec)
self.notify_all() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def handle_response(self, msg, address):
"""Deal with incoming response packets. All answers are held in the cache, and listeners are notified.""" |
now = current_time_millis()
sigs = []
precache = []
for record in msg.answers:
if isinstance(record, DNSSignature):
sigs.append(record)
else:
precache.append(record)
for e in precache:
for s in sigs:
if self.verify(e, s):
# print "DNS: %s verified with %s" % (e,s)
if self.adaptive and e.type == _TYPE_A:
if e.address == '\x00\x00\x00\x00':
e.address = socket.inet_aton(address)
if e in self.cache.entries():
if e.is_expired(now):
for i in self.hooks:
try:
i.remove(e)
except:
pass
self.cache.remove(e)
self.cache.remove(s)
else:
entry = self.cache.get(e)
sig = self.cache.get(s)
if (entry is not None) and (sig is not None):
for i in self.hooks:
try:
i.update(e)
except:
pass
entry.reset_ttl(e)
sig.reset_ttl(s)
else:
e.rrsig = s
self.cache.add(e)
self.cache.add(s)
for i in self.hooks:
try:
i.add(e)
except:
pass
precache.remove(e)
sigs.remove(s)
self.update_record(now, record)
if self.bypass:
for e in precache:
if e in self.cache.entries():
if e.is_expired(now):
for i in self.hooks:
try:
i.remove(e)
except:
pass
self.cache.remove(e)
else:
entry = self.cache.get(e)
if (entry is not None):
for i in self.hooks:
try:
i.update(e)
except:
pass
entry.reset_ttl(e)
else:
self.cache.add(e)
for i in self.hooks:
try:
i.add(e)
except:
pass
self.update_record(now, record) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send(self, out, addr=_MDNS_ADDR, port=_MDNS_PORT):
"""Sends an outgoing packet.""" |
# This is a quick test to see if we can parse the packets we generate
#temp = DNSIncoming(out.packet())
for i in self.intf.values():
try:
return i.sendto(out.packet(), 0, (addr, port))
except:
traceback.print_exc()
# Ignore this, it may be a temporary loss of network connection
return -1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def close(self):
"""Ends the background threads, and prevent this instance from servicing further queries.""" |
if globals()['_GLOBAL_DONE'] == 0:
globals()['_GLOBAL_DONE'] = 1
self.notify_all()
self.engine.notify()
self.unregister_all_services()
for i in self.intf.values():
try:
# there are cases, when we start mDNS without network
i.setsockopt(socket.SOL_IP, socket.IP_DROP_MEMBERSHIP,
socket.inet_aton(_MDNS_ADDR) + \
socket.inet_aton('0.0.0.0'))
except:
pass
i.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute(self, identity_records: 'RDD', old_state_rdd: Optional['RDD'] = None) -> 'RDD': """ Executes Blurr BTS with the given records. old_state_rdd can be provided to load an older state from a previous run. :param identity_records: RDD of the form Tuple[Identity, List[TimeAndRecord]] :param old_state_rdd: A previous streaming BTS state RDD as Tuple[Identity, Streaming BTS State] :return: RDD[Identity, Tuple[Streaming BTS State, List of Window BTS output]] """ |
identity_records_with_state = identity_records
if old_state_rdd:
identity_records_with_state = identity_records.fullOuterJoin(old_state_rdd)
return identity_records_with_state.map(lambda x: self._execute_per_identity_records(x)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_record_rdd_from_json_files(self, json_files: List[str], data_processor: DataProcessor = SimpleJsonDataProcessor(), spark_session: Optional['SparkSession'] = None) -> 'RDD': """ Reads the data from the given json_files path and converts them into the `Record`s format for processing. `data_processor` is used to process the per event data in those files to convert them into `Record`. :param json_files: List of json file paths. Regular Spark path wildcards are accepted. :param data_processor: `DataProcessor` to process each event in the json files. :param spark_session: `SparkSession` to use for execution. If None is provided then a basic `SparkSession` is created. :return: RDD containing Tuple[Identity, List[TimeAndRecord]] which can be used in `execute()` """ |
spark_context = get_spark_session(spark_session).sparkContext
raw_records: 'RDD' = spark_context.union(
[spark_context.textFile(file) for file in json_files])
return raw_records.mapPartitions(
lambda x: self.get_per_identity_records(x, data_processor)).groupByKey().mapValues(list) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_record_rdd_from_rdd( self, rdd: 'RDD', data_processor: DataProcessor = SimpleDictionaryDataProcessor(), ) -> 'RDD': """ Converts a RDD of raw events into the `Record`s format for processing. `data_processor` is used to process the per row data to convert them into `Record`. :param rdd: RDD containing the raw events. :param data_processor: `DataProcessor` to process each row in the given `rdd`. :return: RDD containing Tuple[Identity, List[TimeAndRecord]] which can be used in `execute()` """ |
return rdd.mapPartitions(
lambda x: self.get_per_identity_records(x, data_processor)).groupByKey().mapValues(list) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_output_file(self, path: str, per_identity_data: 'RDD', spark_session: Optional['SparkSession'] = None) -> None: """ Basic helper function to persist data to disk. If window BTS was provided then the window BTS output to written in csv format, otherwise, the streaming BTS output is written in JSON format to the `path` provided :param path: Path where the output should be written. :param per_identity_data: Output of the `execute()` call. :param spark_session: `SparkSession` to use for execution. If None is provided then a basic `SparkSession` is created. :return: """ |
_spark_session_ = get_spark_session(spark_session)
if not self._window_bts:
per_identity_data.flatMap(
lambda x: [json.dumps(data, cls=BlurrJSONEncoder) for data in x[1][0].items()]
).saveAsTextFile(path)
else:
# Convert to a DataFrame first so that the data can be saved as a CSV
_spark_session_.createDataFrame(per_identity_data.flatMap(lambda x: x[1][1])).write.csv(
path, header=True) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def print_output(self, per_identity_data: 'RDD') -> None: """ Basic helper function to write data to stdout. If window BTS was provided then the window BTS output is written, otherwise, the streaming BTS output is written to stdout. WARNING - For large datasets this will be extremely slow. :param per_identity_data: Output of the `execute()` call. """ |
if not self._window_bts:
data = per_identity_data.flatMap(
lambda x: [json.dumps(data, cls=BlurrJSONEncoder) for data in x[1][0].items()])
else:
# Convert to a DataFrame first so that the data can be saved as a CSV
data = per_identity_data.map(
lambda x: json.dumps((x[0], x[1][1]), cls=BlurrJSONEncoder))
for row in data.collect():
print(row) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_executable(executable, path=None):
""" As distutils.spawn.find_executable, but on Windows, look up every extension declared in PATHEXT instead of just `.exe` """ |
if sys.platform != 'win32':
return distutils.spawn.find_executable(executable, path)
if path is None:
path = os.environ['PATH']
paths = path.split(os.pathsep)
extensions = os.environ.get('PATHEXT', '.exe').split(os.pathsep)
base, ext = os.path.splitext(executable)
if not os.path.isfile(executable):
for p in paths:
for ext in extensions:
f = os.path.join(p, base + ext)
if os.path.isfile(f):
return f
return None
else:
return executable |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_environment_dict(overrides):
""" Create and return a copy of os.environ with the specified overrides """ |
result = os.environ.copy()
result.update(overrides or {})
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get(self, server):
""" Retrieve credentials for `server`. If no credentials are found, a `StoreError` will be raised. """ |
if not isinstance(server, six.binary_type):
server = server.encode('utf-8')
data = self._execute('get', server)
result = json.loads(data.decode('utf-8'))
# docker-credential-pass will return an object for inexistent servers
# whereas other helpers will exit with returncode != 0. For
# consistency, if no significant data is returned,
# raise CredentialsNotFound
if result['Username'] == '' and result['Secret'] == '':
raise errors.CredentialsNotFound(
'No matching credentials in {}'.format(self.program)
)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def store(self, server, username, secret):
""" Store credentials for `server`. Raises a `StoreError` if an error occurs. """ |
data_input = json.dumps({
'ServerURL': server,
'Username': username,
'Secret': secret
}).encode('utf-8')
return self._execute('store', data_input) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def erase(self, server):
""" Erase credentials for `server`. Raises a `StoreError` if an error occurs. """ |
if not isinstance(server, six.binary_type):
server = server.encode('utf-8')
self._execute('erase', server) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def extend_schema_spec(self) -> None: """ Injects the identity field """ |
super().extend_schema_spec()
identity_field = {
'Name': '_identity',
'Type': BtsType.STRING,
'Value': 'identity',
ATTRIBUTE_INTERNAL: True
}
if self.ATTRIBUTE_FIELDS in self._spec:
self._spec[self.ATTRIBUTE_FIELDS].insert(0, identity_field)
self.schema_loader.add_schema_spec(identity_field, self.fully_qualified_name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _persist(self) -> None: """ Persists the current data group """ |
if self._store:
self._store.save(self._key, self._snapshot) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_errors(self, *errors: Union[BaseSchemaError, SchemaErrorCollection]) -> None: """ Adds errors to the error store for the schema """ |
for error in errors:
self._error_cache.add(error) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def global_add(self, key: str, value: Any) -> None: """ Adds a key and value to the global dictionary """ |
self.global_context[key] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _copy_files(source, target):
""" Copy all the files in source directory to target. Ignores subdirectories. """ |
source_files = listdir(source)
if not exists(target):
makedirs(target)
for filename in source_files:
full_filename = join(source, filename)
if isfile(full_filename):
shutil.copy(full_filename, target) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_copy(self):
""" Initialises a temporary directory structure and copy of MAGICC configuration files and binary. """ |
if self.executable is None or not isfile(self.executable):
raise FileNotFoundError(
"Could not find MAGICC{} executable: {}".format(
self.version, self.executable
)
)
if self.is_temp:
assert (
self.root_dir is None
), "A temp copy for this instance has already been created"
self.root_dir = mkdtemp(prefix="pymagicc-")
if exists(self.run_dir):
raise Exception("A copy of MAGICC has already been created.")
if not exists(self.root_dir):
makedirs(self.root_dir)
exec_dir = basename(self.original_dir)
# Copy a subset of folders from the MAGICC `original_dir`
# Also copy anything which is in the root of the MAGICC distribution
# Assumes that the MAGICC binary is in a folder one level below the root
# of the MAGICC distribution. i.e. /run/magicc.exe or /bin/magicc
dirs_to_copy = [".", "bin", "run"]
# Check that the executable is in a valid sub directory
assert exec_dir in dirs_to_copy, "binary must be in bin/ or run/ directory"
for d in dirs_to_copy:
source_dir = abspath(join(self.original_dir, "..", d))
if exists(source_dir):
_copy_files(source_dir, join(self.root_dir, d))
# Create an empty out dir
# MAGICC assumes that the 'out' directory already exists
makedirs(join(self.root_dir, "out"))
# Create basic configuration files so magicc can run
self.set_years()
self.set_config() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run(self, scenario=None, only=None, **kwargs):
""" Run MAGICC and parse the output. As a reminder, putting ``out_parameters=1`` will cause MAGICC to write out its parameters into ``out/PARAMETERS.OUT`` and they will then be read into ``output.metadata["parameters"]`` where ``output`` is the returned object. Parameters scenario : :obj:`pymagicc.io.MAGICCData` Scenario to run. If None MAGICC will simply run with whatever config has already been set. only : list of str If not None, only extract variables in this list. kwargs Other config values to pass to MAGICC for the run Returns ------- :obj:`pymagicc.io.MAGICCData` MAGICCData object containing that data in its ``df`` attribute and metadata and parameters (depending on the value of ``include_parameters``) in its ``metadata`` attribute. Raises ------ ValueError If no output is found which matches the list specified in ``only``. """ |
if not exists(self.root_dir):
raise FileNotFoundError(self.root_dir)
if self.executable is None:
raise ValueError(
"MAGICC executable not found, try setting an environment variable `MAGICC_EXECUTABLE_{}=/path/to/binary`".format(
self.version
)
)
if scenario is not None:
kwargs = self.set_emission_scenario_setup(scenario, kwargs)
yr_config = {}
if "startyear" in kwargs:
yr_config["startyear"] = kwargs.pop("startyear")
if "endyear" in kwargs:
yr_config["endyear"] = kwargs.pop("endyear")
if yr_config:
self.set_years(**yr_config)
# should be able to do some other nice metadata stuff re how magicc was run
# etc. here
kwargs.setdefault("rundate", get_date_time_string())
self.update_config(**kwargs)
self.check_config()
exec_dir = basename(self.original_dir)
command = [join(self.root_dir, exec_dir, self.binary_name)]
if not IS_WINDOWS and self.binary_name.endswith(".exe"): # pragma: no cover
command.insert(0, "wine")
# On Windows shell=True is required.
subprocess.check_call(command, cwd=self.run_dir, shell=IS_WINDOWS)
outfiles = self._get_output_filenames()
read_cols = {"climate_model": ["MAGICC{}".format(self.version)]}
if scenario is not None:
read_cols["model"] = scenario["model"].unique().tolist()
read_cols["scenario"] = scenario["scenario"].unique().tolist()
else:
read_cols.setdefault("model", ["unspecified"])
read_cols.setdefault("scenario", ["unspecified"])
mdata = None
for filepath in outfiles:
try:
openscm_var = _get_openscm_var_from_filepath(filepath)
if only is None or openscm_var in only:
tempdata = MAGICCData(
join(self.out_dir, filepath), columns=deepcopy(read_cols)
)
mdata = mdata.append(tempdata) if mdata is not None else tempdata
except (NoReaderWriterError, InvalidTemporalResError):
continue
if mdata is None:
error_msg = "No output found for only={}".format(only)
raise ValueError(error_msg)
try:
run_paras = self.read_parameters()
self.config = run_paras
mdata.metadata["parameters"] = run_paras
except FileNotFoundError:
pass
return mdata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_config(self):
"""Check that our MAGICC ``.CFG`` files are set to safely work with PYMAGICC For further detail about why this is required, please see :ref:`MAGICC flags`. Raises ------ ValueError If we are not certain that the config written by PYMAGICC will overwrite all other config i.e. that there will be no unexpected behaviour. A ValueError will also be raised if the user tries to use more than one scenario file. """ |
cfg_error_msg = (
"PYMAGICC is not the only tuning model that will be used by "
"`MAGCFG_USER.CFG`: your run is likely to fail/do odd things"
)
emisscen_error_msg = (
"You have more than one `FILE_EMISSCEN_X` flag set. Using more than "
"one emissions scenario is hard to debug and unnecessary with "
"Pymagicc's dataframe scenario input. Please combine all your "
"scenarios into one dataframe with Pymagicc and pandas, then feed "
"this single Dataframe into Pymagicc's run API."
)
nml_to_check = "nml_allcfgs"
usr_cfg = read_cfg_file(join(self.run_dir, "MAGCFG_USER.CFG"))
for k in usr_cfg[nml_to_check]:
if k.startswith("file_tuningmodel"):
first_tuningmodel = k in ["file_tuningmodel", "file_tuningmodel_1"]
if first_tuningmodel:
if usr_cfg[nml_to_check][k] != "PYMAGICC":
raise ValueError(cfg_error_msg)
elif usr_cfg[nml_to_check][k] not in ["USER", ""]:
raise ValueError(cfg_error_msg)
elif k.startswith("file_emisscen_"):
if usr_cfg[nml_to_check][k] not in ["NONE", ""]:
raise ValueError(emisscen_error_msg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, mdata, name):
"""Write an input file to disk Parameters mdata : :obj:`pymagicc.io.MAGICCData` A MAGICCData instance with the data to write name : str The name of the file to write. The file will be written to the MAGICC instance's run directory i.e. ``self.run_dir`` """ |
mdata.write(join(self.run_dir, name), self.version) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_parameters(self):
""" Read a parameters.out file Returns ------- dict A dictionary containing all the configuration used by MAGICC """ |
param_fname = join(self.out_dir, "PARAMETERS.OUT")
if not exists(param_fname):
raise FileNotFoundError("No PARAMETERS.OUT found")
with open(param_fname) as nml_file:
parameters = dict(f90nml.read(nml_file))
for group in ["nml_years", "nml_allcfgs", "nml_outputcfgs"]:
parameters[group] = dict(parameters[group])
for k, v in parameters[group].items():
parameters[group][k] = _clean_value(v)
parameters[group.replace("nml_", "")] = parameters.pop(group)
self.config = parameters
return parameters |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_temp_copy(self):
""" Removes a temporary copy of the MAGICC version shipped with Pymagicc. """ |
if self.is_temp and self.root_dir is not None:
shutil.rmtree(self.root_dir)
self.root_dir = None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_config( self, filename="MAGTUNE_PYMAGICC.CFG", top_level_key="nml_allcfgs", **kwargs ):
""" Create a configuration file for MAGICC. Writes a fortran namelist in run_dir. Parameters filename : str Name of configuration file to write top_level_key : str Name of namelist to be written in the configuration file kwargs Other parameters to pass to the configuration file. No validation on the parameters is performed. Returns ------- dict The contents of the namelist which was written to file """ |
kwargs = self._format_config(kwargs)
fname = join(self.run_dir, filename)
conf = {top_level_key: kwargs}
f90nml.write(conf, fname, force=True)
return conf |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_config( self, filename="MAGTUNE_PYMAGICC.CFG", top_level_key="nml_allcfgs", **kwargs ):
"""Updates a configuration file for MAGICC Updates the contents of a fortran namelist in the run directory, creating a new namelist if none exists. Parameters filename : str Name of configuration file to write top_level_key : str Name of namelist to be written in the configuration file kwargs Other parameters to pass to the configuration file. No validation on the parameters is performed. Returns ------- dict The contents of the namelist which was written to file """ |
kwargs = self._format_config(kwargs)
fname = join(self.run_dir, filename)
if exists(fname):
conf = f90nml.read(fname)
else:
conf = {top_level_key: {}}
conf[top_level_key].update(kwargs)
f90nml.write(conf, fname, force=True)
return conf |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_zero_config(self):
"""Set config such that radiative forcing and temperature output will be zero This method is intended as a convenience only, it does not handle everything in an obvious way. Adjusting the parameter settings still requires great care and may behave unepexctedly. """ |
# zero_emissions is imported from scenarios module
zero_emissions.write(join(self.run_dir, self._scen_file_name), self.version)
time = zero_emissions.filter(variable="Emissions|CH4", region="World")[
"time"
].values
no_timesteps = len(time)
# value doesn't actually matter as calculations are done from difference but
# chose sensible value nonetheless
ch4_conc_pi = 722
ch4_conc = ch4_conc_pi * np.ones(no_timesteps)
ch4_conc_df = pd.DataFrame(
{
"time": time,
"scenario": "idealised",
"model": "unspecified",
"climate_model": "unspecified",
"variable": "Atmospheric Concentrations|CH4",
"unit": "ppb",
"todo": "SET",
"region": "World",
"value": ch4_conc,
}
)
ch4_conc_writer = MAGICCData(ch4_conc_df)
ch4_conc_filename = "HIST_CONSTANT_CH4_CONC.IN"
ch4_conc_writer.metadata = {
"header": "Constant pre-industrial CH4 concentrations"
}
ch4_conc_writer.write(join(self.run_dir, ch4_conc_filename), self.version)
fgas_conc_pi = 0
fgas_conc = fgas_conc_pi * np.ones(no_timesteps)
# MAGICC6 doesn't read this so not a problem, for MAGICC7 we might have to
# write each file separately
varname = "FGAS_CONC"
fgas_conc_df = pd.DataFrame(
{
"time": time,
"scenario": "idealised",
"model": "unspecified",
"climate_model": "unspecified",
"variable": varname,
"unit": "ppt",
"todo": "SET",
"region": "World",
"value": fgas_conc,
}
)
fgas_conc_writer = MAGICCData(fgas_conc_df)
fgas_conc_filename = "HIST_ZERO_{}.IN".format(varname)
fgas_conc_writer.metadata = {"header": "Zero concentrations"}
fgas_conc_writer.write(join(self.run_dir, fgas_conc_filename), self.version)
emis_config = self._fix_any_backwards_emissions_scen_key_in_config(
{"file_emissionscenario": self._scen_file_name}
)
self.set_config(
**emis_config,
rf_initialization_method="ZEROSTARTSHIFT",
rf_total_constantafteryr=10000,
file_co2i_emis="",
file_co2b_emis="",
co2_switchfromconc2emis_year=1750,
file_ch4i_emis="",
file_ch4b_emis="",
file_ch4n_emis="",
file_ch4_conc=ch4_conc_filename,
ch4_switchfromconc2emis_year=10000,
file_n2oi_emis="",
file_n2ob_emis="",
file_n2on_emis="",
file_n2o_conc="",
n2o_switchfromconc2emis_year=1750,
file_noxi_emis="",
file_noxb_emis="",
file_noxi_ot="",
file_noxb_ot="",
file_noxt_rf="",
file_soxnb_ot="",
file_soxi_ot="",
file_soxt_rf="",
file_soxi_emis="",
file_soxb_emis="",
file_soxn_emis="",
file_oci_emis="",
file_ocb_emis="",
file_oci_ot="",
file_ocb_ot="",
file_oci_rf="",
file_ocb_rf="",
file_bci_emis="",
file_bcb_emis="",
file_bci_ot="",
file_bcb_ot="",
file_bci_rf="",
file_bcb_rf="",
bcoc_switchfromrf2emis_year=1750,
file_nh3i_emis="",
file_nh3b_emis="",
file_nmvoci_emis="",
file_nmvocb_emis="",
file_coi_emis="",
file_cob_emis="",
file_mineraldust_rf="",
file_landuse_rf="",
file_bcsnow_rf="",
# rf_fgassum_scale=0, # this appears to do nothing, hence the next two lines
file_fgas_conc=[fgas_conc_filename] * 12,
fgas_switchfromconc2emis_year=10000,
rf_mhalosum_scale=0,
mhalo_switch_conc2emis_yr=1750,
stratoz_o3scale=0,
rf_volcanic_scale=0,
rf_solar_scale=0,
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_years(self, startyear=1765, endyear=2100):
""" Set the start and end dates of the simulations. Parameters startyear : int Start year of the simulation endyear : int End year of the simulation Returns ------- dict The contents of the namelist """ |
# TODO: test altering stepsperyear, I think 1, 2 and 24 should all work
return self.set_config(
"MAGCFG_NMLYEARS.CFG",
"nml_years",
endyear=endyear,
startyear=startyear,
stepsperyear=12,
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_output_variables(self, write_ascii=True, write_binary=False, **kwargs):
"""Set the output configuration, minimising output as much as possible There are a number of configuration parameters which control which variables are written to file and in which format. Limiting the variables that are written to file can greatly speed up the running of MAGICC. By default, calling this function without specifying any variables will disable all output by setting all of MAGICC's ``out_xx`` flags to ``0``. This convenience function should not be confused with ``set_config`` or ``update_config`` which allow the user to set/update the configuration flags directly, without the more convenient syntax and default behaviour provided by this function. Parameters write_ascii : bool If true, MAGICC is configured to write output files as human readable ascii files. write_binary : bool If true, MAGICC is configured to write binary output files. These files are much faster to process and write, but are not human readable. **kwargs: List of variables to write out. A list of possible options are as follows. This may not be a complete list. 'emissions', 'gwpemissions', 'sum_gwpemissions', 'concentrations', 'carboncycle', 'forcing', 'surfaceforcing', 'permafrost', 'temperature', 'sealevel', 'parameters', 'misc', 'lifetimes', 'timeseriesmix', 'rcpdata', 'summaryidx', 'inverseemis', 'tempoceanlayers', 'oceanarea', 'heatuptake', 'warnings', 'precipinput', 'aogcmtuning', 'ccycletuning', 'observationaltuning', 'keydata_1', 'keydata_2' """ |
assert (
write_ascii or write_binary
), "write_binary and/or write_ascii must be configured"
if write_binary and write_ascii:
ascii_binary = "BOTH"
elif write_ascii:
ascii_binary = "ASCII"
else:
ascii_binary = "BINARY"
# defaults
outconfig = {
"out_emissions": 0,
"out_gwpemissions": 0,
"out_sum_gwpemissions": 0,
"out_concentrations": 0,
"out_carboncycle": 0,
"out_forcing": 0,
"out_surfaceforcing": 0,
"out_permafrost": 0,
"out_temperature": 0,
"out_sealevel": 0,
"out_parameters": 0,
"out_misc": 0,
"out_timeseriesmix": 0,
"out_rcpdata": 0,
"out_summaryidx": 0,
"out_inverseemis": 0,
"out_tempoceanlayers": 0,
"out_heatuptake": 0,
"out_ascii_binary": ascii_binary,
"out_warnings": 0,
"out_precipinput": 0,
"out_aogcmtuning": 0,
"out_ccycletuning": 0,
"out_observationaltuning": 0,
"out_keydata_1": 0,
"out_keydata_2": 0,
}
if self.version == 7:
outconfig["out_oceanarea"] = 0
outconfig["out_lifetimes"] = 0
for kw in kwargs:
val = 1 if kwargs[kw] else 0 # convert values to 0/1 instead of booleans
outconfig["out_" + kw.lower()] = val
self.update_config(**outconfig) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def diagnose_tcr_ecs(self, **kwargs):
"""Diagnose TCR and ECS The transient climate response (TCR), is the global-mean temperature response at time at which atmopsheric |CO2| concentrations double in a scenario where atmospheric |CO2| concentrations are increased at 1% per year from pre-industrial levels. The equilibrium climate sensitivity (ECS), is the equilibrium global-mean temperature response to an instantaneous doubling of atmospheric |CO2| concentrations. As MAGICC has no hysteresis in its equilibrium response to radiative forcing, we can diagnose TCR and ECS with one experiment. However, please note that sometimes the run length won't be long enough to allow MAGICC's oceans to fully equilibrate and hence the ECS value might not be what you expect (it should match the value of ``core_climatesensitivity``). Parameters **kwargs parameter values to use in the diagnosis e.g. ``core_climatesensitivity=4`` Returns ------- dict Dictionary with keys: "ecs" - the diagnosed ECS; "tcr" - the diagnosed TCR; "timeseries" - the relevant model input and output timeseries used in the experiment i.e. atmospheric |CO2| concentrations, total radiative forcing and global-mean surface temperature """ |
if self.version == 7:
raise NotImplementedError("MAGICC7 cannot yet diagnose ECS and TCR")
self._diagnose_tcr_ecs_config_setup(**kwargs)
timeseries = self.run(
scenario=None,
only=[
"Atmospheric Concentrations|CO2",
"Radiative Forcing",
"Surface Temperature",
],
)
tcr, ecs = self._get_tcr_ecs_from_diagnosis_results(timeseries)
return {"tcr": tcr, "ecs": ecs, "timeseries": timeseries} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_emission_scenario_setup(self, scenario, config_dict):
"""Set the emissions flags correctly. Parameters scenario : :obj:`pymagicc.io.MAGICCData` Scenario to run. config_dict : dict Dictionary with current input configurations which is to be validated and updated where necessary. Returns ------- dict Updated configuration """ |
self.write(scenario, self._scen_file_name)
# can be lazy in this line as fix backwards key handles errors for us
config_dict["file_emissionscenario"] = self._scen_file_name
config_dict = self._fix_any_backwards_emissions_scen_key_in_config(config_dict)
return config_dict |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def contains(value: Union[str, 'Type']) -> bool: """ Checks if a type is defined """ |
if isinstance(value, str):
return any(value.lower() == i.value for i in Type)
return any(value == i for i in Type) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _calcidxs(func):
"""Return the required indexes based on the given lambda function and the |Timegrids| object handled by module |pub|. Raise a |RuntimeError| if the latter is not available. """ |
timegrids = hydpy.pub.get('timegrids')
if timegrids is None:
raise RuntimeError(
'An Indexer object has been asked for an %s array. Such an '
'array has neither been determined yet nor can it be '
'determined automatically at the moment. Either define an '
'%s array manually and pass it to the Indexer object, or make '
'a proper Timegrids object available within the pub module. '
'In usual HydPy applications, the latter is done '
'automatically.'
% (func.__name__, func.__name__))
idxs = numpy.empty(len(timegrids.init), dtype=int)
for jdx, date in enumerate(hydpy.pub.timegrids.init):
idxs[jdx] = func(date)
return idxs |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def getter_(self, fget) -> 'BaseProperty': """Add the given getter function and its docstring to the property and return it.""" |
self.fget = fget
self.set_doc(fget.__doc__)
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def isready(self, obj) -> bool: """Return |True| or |False| to indicate if the protected property is ready for the given object. If the object is unknow, |ProtectedProperty| returns |False|.""" |
return vars(obj).get(self.name, False) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def allready(self, obj) -> bool: """Return |True| or |False| to indicate whether all protected properties are ready or not.""" |
for prop in self.__properties:
if not prop.isready(obj):
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def call_fget(self, obj) -> Any: """Return the predefined custom value when available, otherwise, the value defined by the getter function.""" |
custom = vars(obj).get(self.name)
if custom is None:
return self.fget(obj)
return custom |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def call_fset(self, obj, value) -> None: """Store the given custom value and call the setter function.""" |
vars(obj)[self.name] = self.fset(obj, value) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def call_fdel(self, obj) -> None: """Remove the predefined custom value and call the delete function.""" |
self.fdel(obj)
try:
del vars(obj)[self.name]
except KeyError:
pass |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _add_lines(specification, module):
"""Return autodoc commands for a basemodels docstring. Note that `collection classes` (e.g. `Model`, `ControlParameters`, `InputSequences` are placed on top of the respective section and the `contained classes` (e.g. model methods, `ControlParameter` instances, `InputSequence` instances at the bottom. This differs from the order of their definition in the respective modules, but results in a better documentation structure. """ |
caption = _all_spec2capt.get(specification, 'dummy')
if caption.split()[-1] in ('parameters', 'sequences', 'Masks'):
exists_collectionclass = True
name_collectionclass = caption.title().replace(' ', '')
else:
exists_collectionclass = False
lines = []
if specification == 'model':
lines += [f'',
f'.. autoclass:: {module.__name__}.Model',
f' :members:',
f' :show-inheritance:',
f' :exclude-members: {", ".join(EXCLUDE_MEMBERS)}']
elif exists_collectionclass:
lines += [f'',
f'.. autoclass:: {module.__name__}.{name_collectionclass}',
f' :members:',
f' :show-inheritance:',
f' :exclude-members: {", ".join(EXCLUDE_MEMBERS)}']
lines += ['',
'.. automodule:: ' + module.__name__,
' :members:',
' :show-inheritance:']
if specification == 'model':
lines += [' :exclude-members: Model']
elif exists_collectionclass:
lines += [' :exclude-members: ' + name_collectionclass]
return lines |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def autodoc_basemodel(module):
"""Add an exhaustive docstring to the given module of a basemodel. Works onlye when all modules of the basemodel are named in the standard way, e.g. `lland_model`, `lland_control`, `lland_inputs`. """ |
autodoc_tuple2doc(module)
namespace = module.__dict__
doc = namespace.get('__doc__')
if doc is None:
doc = ''
basemodulename = namespace['__name__'].split('.')[-1]
modules = {key: value for key, value in namespace.items()
if (isinstance(value, types.ModuleType) and
key.startswith(basemodulename+'_'))}
substituter = Substituter(hydpy.substituter)
lines = []
specification = 'model'
modulename = basemodulename+'_'+specification
if modulename in modules:
module = modules[modulename]
lines += _add_title('Model features', '-')
lines += _add_lines(specification, module)
substituter.add_module(module)
for (title, spec2capt) in (('Parameter features', _PAR_SPEC2CAPT),
('Sequence features', _SEQ_SPEC2CAPT),
('Auxiliary features', _AUX_SPEC2CAPT)):
found_module = False
new_lines = _add_title(title, '-')
for (specification, caption) in spec2capt.items():
modulename = basemodulename+'_'+specification
module = modules.get(modulename)
if module:
found_module = True
new_lines += _add_title(caption, '.')
new_lines += _add_lines(specification, module)
substituter.add_module(module)
if found_module:
lines += new_lines
doc += '\n'.join(lines)
namespace['__doc__'] = doc
basemodule = importlib.import_module(namespace['__name__'])
substituter.add_module(basemodule)
substituter.update_masters()
namespace['substituter'] = substituter |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def autodoc_applicationmodel(module):
"""Improves the docstrings of application models when called at the bottom of the respective module. |autodoc_applicationmodel| requires, similar to |autodoc_basemodel|, that both the application model and its base model are defined in the conventional way. """ |
autodoc_tuple2doc(module)
name_applicationmodel = module.__name__
name_basemodel = name_applicationmodel.split('_')[0]
module_basemodel = importlib.import_module(name_basemodel)
substituter = Substituter(module_basemodel.substituter)
substituter.add_module(module)
substituter.update_masters()
module.substituter = substituter |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _number_of_line(member_tuple):
"""Try to return the number of the first line of the definition of a member of a module.""" |
member = member_tuple[1]
try:
return member.__code__.co_firstlineno
except AttributeError:
pass
try:
return inspect.findsource(member)[1]
except BaseException:
pass
for value in vars(member).values():
try:
return value.__code__.co_firstlineno
except AttributeError:
pass
return 0 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def autodoc_module(module):
"""Add a short summary of all implemented members to a modules docstring. """ |
doc = getattr(module, '__doc__')
if doc is None:
doc = ''
members = []
for name, member in inspect.getmembers(module):
if ((not name.startswith('_')) and
(inspect.getmodule(member) is module)):
members.append((name, member))
members = sorted(members, key=_number_of_line)
if members:
lines = ['\n\nModule :mod:`~%s` implements the following members:\n'
% module.__name__]
for (name, member) in members:
if inspect.isfunction(member):
type_ = 'func'
elif inspect.isclass(member):
type_ = 'class'
else:
type_ = 'obj'
lines.append(' * :%s:`~%s` %s'
% (type_, name, objecttools.description(member)))
doc = doc + '\n\n' + '\n'.join(lines) + '\n\n' + 80*'_'
module.__doc__ = doc |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def autodoc_tuple2doc(module):
"""Include tuples as `CLASSES` of `ControlParameters` and `RUN_METHODS` of `Models` into the respective docstring.""" |
modulename = module.__name__
for membername, member in inspect.getmembers(module):
for tuplename, descr in _name2descr.items():
tuple_ = getattr(member, tuplename, None)
if tuple_:
logstring = f'{modulename}.{membername}.{tuplename}'
if logstring not in _loggedtuples:
_loggedtuples.add(logstring)
lst = [f'\n\n\n {descr}:']
if tuplename == 'CLASSES':
type_ = 'func'
else:
type_ = 'class'
for cls in tuple_:
lst.append(
f' * '
f':{type_}:`{cls.__module__}.{cls.__name__}`'
f' {objecttools.description(cls)}')
doc = getattr(member, '__doc__')
if doc is None:
doc = ''
member.__doc__ = doc + '\n'.join(l for l in lst) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def consider_member(name_member, member, module, class_=None):
"""Return |True| if the given member should be added to the substitutions. If not return |False|. Some examples based on the site-package |numpy|: A constant like |nan| should be added: True Members with a prefixed underscore should not be added: False Members that are actually imported modules should not be added: False Members that are actually defined in other modules should not be added: False Members that are defined in submodules of a given package (either from the standard library or from site-packages) True False For descriptor instances (with method `__get__`) beeing members of classes should be added: True """ |
if name_member.startswith('_'):
return False
if inspect.ismodule(member):
return False
real_module = getattr(member, '__module__', None)
if not real_module:
return True
if real_module != module.__name__:
if class_ and hasattr(member, '__get__'):
return True
if 'hydpy' in real_module:
return False
if module.__name__ not in real_module:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_role(member, cython=False):
"""Return the reStructuredText role `func`, `class`, or `const` best describing the given member. Some examples based on the site-package |numpy|. |numpy.clip| is a function: 'func' |numpy.ndarray| is a class: 'class' |numpy.ndarray.clip| is a method, for which also the `function` role is returned: 'func' For everything else the `constant` role is returned: 'const' When analysing cython extension modules, set the option `cython` flag to |True|. |Double| is correctly identified as a class: 'class' Only with the `cython` flag beeing |True|, for everything else the `function` text role is returned (doesn't make sense here, but the |numpy| module is not something defined in module |pointerutils| anyway):
'func' """ |
if inspect.isroutine(member) or isinstance(member, numpy.ufunc):
return 'func'
elif inspect.isclass(member):
return 'class'
elif cython:
return 'func'
return 'const' |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_substitution(self, short, medium, long, module):
"""Add the given substitutions both as a `short2long` and a `medium2long` mapping. Assume `variable1` is defined in the hydpy module `module1` and the short and medium descriptions are `var1` and `mod1.var1`: .. var1 replace:: module1.variable1 .. mod1.var1 replace:: module1.variable1 Adding `variable2` of `module2` has no effect on the predefined substitutions: .. var1 replace:: module1.variable1 .. var2 replace:: module2.variable2 .. mod1.var1 replace:: module1.variable1 .. mod2.var2 replace:: module2.variable2 But when adding `variable1` of `module2`, the `short2long` mapping of `variable1` would become inconclusive, which is why the new one (related to `module2`) is not stored and the old one (related to `module1`) is removed: .. var2 replace:: module2.variable2 .. mod1.var1 replace:: module1.variable1 .. mod2.var1 replace:: module2.variable1 .. mod2.var2 replace:: module2.variable2 Adding `variable2` of `module2` accidentally again, does not result in any undesired side-effects: .. var2 replace:: module2.variable2 .. mod1.var1 replace:: module1.variable1 .. mod2.var1 replace:: module2.variable1 .. mod2.var2 replace:: module2.variable2 In order to reduce the risk of name conflicts, only the `medium2long` mapping is supported for modules not part of the *HydPy* package: .. var2 replace:: module2.variable2 .. mod1.var1 replace:: module1.variable1 .. mod2.var1 replace:: module2.variable1 .. mod2.var2 replace:: module2.variable2 .. mod3.var3 replace:: module3.variable3 The only exception to this rule is |builtins|, for which only the `short2long` mapping is supported (note also, that the module name `builtins` is removed from string `long`):
.. str replace:: :func:`str` .. var2 replace:: module2.variable2 .. mod1.var1 replace:: module1.variable1 .. mod2.var1 replace:: module2.variable1 .. mod2.var2 replace:: module2.variable2 .. mod3.var3 replace:: module3.variable3 """ |
name = module.__name__
if 'builtin' in name:
self._short2long[short] = long.split('~')[0] + long.split('.')[-1]
else:
if ('hydpy' in name) and (short not in self._blacklist):
if short in self._short2long:
if self._short2long[short] != long:
self._blacklist.add(short)
del self._short2long[short]
else:
self._short2long[short] = long
self._medium2long[medium] = long |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_module(self, module, cython=False):
"""Add the given module, its members, and their submembers. The first examples are based on the site-package |numpy|: which is passed to method |Substituter.add_module|: Firstly, the module itself is added: |numpy| :mod:`~numpy` Secondly, constants like |numpy.nan| are added: |numpy.nan| :const:`~numpy.nan` Thirdly, functions like |numpy.clip| are added: |numpy.clip| :func:`~numpy.clip` Fourthly, clases line |numpy.ndarray| are added: |numpy.ndarray| :class:`~numpy.ndarray` When adding Cython modules, the `cython` flag should be set |True|: |PPDouble.set_pointer| \ :func:`~hydpy.cythons.autogen.pointerutils.PPDouble.set_pointer` |pointerutils.PPDouble.set_pointer| \ :func:`~hydpy.cythons.autogen.pointerutils.PPDouble.set_pointer` """ |
name_module = module.__name__.split('.')[-1]
short = ('|%s|'
% name_module)
long = (':mod:`~%s`'
% module.__name__)
self._short2long[short] = long
for (name_member, member) in vars(module).items():
if self.consider_member(
name_member, member, module):
role = self.get_role(member, cython)
short = ('|%s|'
% name_member)
medium = ('|%s.%s|'
% (name_module,
name_member))
long = (':%s:`~%s.%s`'
% (role,
module.__name__,
name_member))
self.add_substitution(short, medium, long, module)
if inspect.isclass(member):
for name_submember, submember in vars(member).items():
if self.consider_member(
name_submember, submember, module, member):
role = self.get_role(submember, cython)
short = ('|%s.%s|'
% (name_member,
name_submember))
medium = ('|%s.%s.%s|'
% (name_module,
name_member,
name_submember))
long = (':%s:`~%s.%s.%s`'
% (role,
module.__name__,
name_member,
name_submember))
self.add_substitution(short, medium, long, module) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_modules(self, package):
"""Add the modules of the given package without their members.""" |
for name in os.listdir(package.__path__[0]):
if name.startswith('_'):
continue
name = name.split('.')[0]
short = '|%s|' % name
long = ':mod:`~%s.%s`' % (package.__package__, name)
self._short2long[short] = long |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_masters(self):
"""Update all `master` |Substituter| objects. If a |Substituter| object is passed to the constructor of another |Substituter| object, they become `master` and `slave`: True True During initialization, all mappings handled by the master object are passed to its new slave: |Node| :class:`~hydpy.core.devicetools.Node` |devicetools.Node| :class:`~hydpy.core.devicetools.Node` Updating a slave, does not affect its master directly: |HydPy| :class:`~hydpy.core.hydpytools.HydPy` |hydpytools.HydPy| :class:`~hydpy.core.hydpytools.HydPy` Through calling |Substituter.update_masters|, the `medium2long` mappings are passed from the slave to its master: |hydpytools.HydPy| :class:`~hydpy.core.hydpytools.HydPy` Then each master object updates its own master object also: |hydpytools.HydPy| :class:`~hydpy.core.hydpytools.HydPy` In reverse, subsequent updates of master objects to not affect their slaves directly: |Masks| :class:`~hydpy.core.masktools.Masks` |masktools.Masks| :class:`~hydpy.core.masktools.Masks` Through calling |Substituter.update_slaves|, the `medium2long` mappings are passed the master to all of its slaves: |masktools.Masks| :class:`~hydpy.core.masktools.Masks` |masktools.Masks| :class:`~hydpy.core.masktools.Masks` """ |
if self.master is not None:
self.master._medium2long.update(self._medium2long)
self.master.update_masters() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_slaves(self):
"""Update all `slave` |Substituter| objects. See method |Substituter.update_masters| for further information. """ |
for slave in self.slaves:
slave._medium2long.update(self._medium2long)
slave.update_slaves() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_commands(self, source=None):
"""Return a string containing multiple `reStructuredText` replacements with the substitutions currently defined. Some examples based on the subpackage |optiontools|: When calling |Substituter.get_commands| with the `source` argument, the complete `short2long` and `medium2long` mappings are translated into replacement commands (only a few of them are shown):
.. |Options.autocompile| replace:: \ :const:`~hydpy.core.optiontools.Options.autocompile` .. |Options.checkseries| replace:: \ :const:`~hydpy.core.optiontools.Options.checkseries` .. |optiontools.Options.warntrim| replace:: \ :const:`~hydpy.core.optiontools.Options.warntrim` .. |optiontools.Options| replace:: \ :class:`~hydpy.core.optiontools.Options` Through passing a string (usually the source code of a file to be documented), only the replacement commands relevant for this string are translated: .. |Options.reprdigits| replace:: \ :const:`~hydpy.core.optiontools.Options.reprdigits` """ |
commands = []
for key, value in self:
if (source is None) or (key in source):
commands.append('.. %s replace:: %s' % (key, value))
return '\n'.join(commands) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find(self, text):
"""Print all substitutions that include the given text string.""" |
for key, value in self:
if (text in key) or (text in value):
print(key, value) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def print_progress(wrapped, _=None, args=None, kwargs=None):
"""Add print commands time to the given function informing about execution time. To show how the |print_progress| decorator works, we need to modify the functions used by |print_progress| to gain system time information available in module |time|. First, we mock the functions |time.strftime| and |time.perf_counter|: The mock of |time.strftime| shall respond to two calls, as if the first call to a decorated function occurs at quarter past eight, and the second one two seconds later: The mock of |time.perf_counter| shall respond to four calls, as if the subsequent calls by decorated functions occur at second 1, 3, 4, and 7: Now we decorate two test functions. The first one does nothing; the second one only calls the first one: The first example shows that the output is appropriately indented, tat the returned times are at the right place, that the calculated execution the is correct, and that the mock of |time.strftime| received a valid format string: method test2 started at 20:15:00 method test1 started at 20:15:02 seconds elapsed: 1 seconds elapsed: 6 call('%H:%M:%S') The second example verifies that resetting the indentation works: method test2 started at 20:15:00 method test1 started at 20:15:02 seconds elapsed: 1 seconds elapsed: 6 The last example shows that disabling the |Options.printprogress| option works as expected: """ |
global _printprogress_indentation
_printprogress_indentation += 4
try:
if hydpy.pub.options.printprogress:
blanks = ' ' * _printprogress_indentation
name = wrapped.__name__
time_ = time.strftime('%H:%M:%S')
with PrintStyle(color=34, font=1):
print(f'{blanks}method {name} started at {time_}')
seconds = time.perf_counter()
sys.stdout.flush()
wrapped(*args, **kwargs)
blanks = ' ' * (_printprogress_indentation+4)
seconds = time.perf_counter()-seconds
with PrintStyle(color=34, font=1):
print(f'{blanks}seconds elapsed: {seconds}')
sys.stdout.flush()
else:
wrapped(*args, **kwargs)
finally:
_printprogress_indentation -= 4 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def progressbar(iterable, length=23):
"""Print a simple progress bar while processing the given iterable. Function |progressbar| does print the progress bar when option `printprogress` is activted: You can pass an iterable object. Say you want to calculate the the sum of all integer values from 1 to 100 and print the progress of the calculation. Using function |range| (which returns a list in Python 2 and an iterator in Python3, but both are fine), one just has to interpose function |progressbar|: *********************** 5050 To prevent possible interim print commands from dismembering the status bar, they are delayed until the status bar is complete. For intermediate print outs of each fiftieth calculation, the result looks as follows: *********************** 50 1275 100 5050 The number of characters of the progress bar can be changed: ************************************************** But its maximum number of characters is restricted by the length of the given iterable: |--------| ********** The smallest possible progress bar has two characters: || ** For iterables of length one or zero, no progress bar is plottet: The same is True when the `printprogress` option is inactivated: """ |
if hydpy.pub.options.printprogress and (len(iterable) > 1):
temp_name = os.path.join(tempfile.gettempdir(),
'HydPy_progressbar_stdout')
temp_stdout = open(temp_name, 'w')
real_stdout = sys.stdout
try:
sys.stdout = temp_stdout
nmbstars = min(len(iterable), length)
nmbcounts = len(iterable)/nmbstars
indentation = ' '*max(_printprogress_indentation, 0)
with PrintStyle(color=36, font=1, file=real_stdout):
print(' %s|%s|\n%s ' % (indentation,
'-'*(nmbstars-2),
indentation),
end='',
file=real_stdout)
counts = 1.
for next_ in iterable:
counts += 1.
if counts >= nmbcounts:
print(end='*', file=real_stdout)
counts -= nmbcounts
yield next_
finally:
try:
temp_stdout.close()
except BaseException:
pass
sys.stdout = real_stdout
print()
with open(temp_name, 'r') as temp_stdout:
sys.stdout.write(temp_stdout.read())
sys.stdout.flush()
else:
for next_ in iterable:
yield next_ |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_parameteritemtypes(self) -> None: """Get the types of all current exchange items supposed to change the values of |Parameter| objects.""" |
for item in state.parameteritems:
self._outputs[item.name] = self._get_itemtype(item) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_conditionitemtypes(self) -> None: """Get the types of all current exchange items supposed to change the values of |StateSequence| or |LogSequence| objects.""" |
for item in state.conditionitems:
self._outputs[item.name] = self._get_itemtype(item) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_getitemtypes(self) -> None: """Get the types of all current exchange items supposed to return the values of |Parameter| or |Sequence| objects or the time series of |IOSequence| objects.""" |
for item in state.getitems:
type_ = self._get_itemtype(item)
for name, _ in item.yield_name2value():
self._outputs[name] = type_ |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def POST_timegrid(self) -> None: """Change the current simulation |Timegrid|.""" |
init = hydpy.pub.timegrids.init
sim = hydpy.pub.timegrids.sim
sim.firstdate = self._inputs['firstdate']
sim.lastdate = self._inputs['lastdate']
state.idx1 = init[sim.firstdate]
state.idx2 = init[sim.lastdate] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_parameteritemvalues(self) -> None: """Get the values of all |ChangeItem| objects handling |Parameter| objects.""" |
for item in state.parameteritems:
self._outputs[item.name] = item.value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_conditionitemvalues(self) -> None: """Get the values of all |ChangeItem| objects handling |StateSequence| or |LogSequence| objects.""" |
for item in state.conditionitems:
self._outputs[item.name] = item.value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_getitemvalues(self) -> None: """Get the values of all |Variable| objects observed by the current |GetItem| objects. For |GetItem| objects observing time series, |HydPyServer.GET_getitemvalues| returns only the values within the current simulation period. """ |
for item in state.getitems:
for name, value in item.yield_name2value(state.idx1, state.idx2):
self._outputs[name] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_load_conditionvalues(self) -> None: """Assign the |StateSequence| or |LogSequence| object values available for the current simulation start point to the current |HydPy| instance. When the simulation start point is identical with the initialisation time point and you did not save conditions for it beforehand, the "original" initial conditions are used (normally those of the conditions files of the respective *HydPy* project). """ |
try:
state.hp.conditions = state.conditions[self._id][state.idx1]
except KeyError:
if state.idx1:
self._statuscode = 500
raise RuntimeError(
f'Conditions for ID `{self._id}` and time point '
f'`{hydpy.pub.timegrids.sim.firstdate}` are required, '
f'but have not been calculated so far.')
else:
state.hp.conditions = state.init_conditions |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_save_conditionvalues(self) -> None: """Save the |StateSequence| and |LogSequence| object values of the current |HydPy| instance for the current simulation endpoint.""" |
state.conditions[self._id] = state.conditions.get(self._id, {})
state.conditions[self._id][state.idx2] = state.hp.conditions |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_save_parameteritemvalues(self) -> None: """Save the values of those |ChangeItem| objects which are handling |Parameter| objects.""" |
for item in state.parameteritems:
state.parameteritemvalues[self._id][item.name] = item.value.copy() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_savedparameteritemvalues(self) -> None: """Get the previously saved values of those |ChangeItem| objects which are handling |Parameter| objects.""" |
dict_ = state.parameteritemvalues.get(self._id)
if dict_ is None:
self.GET_parameteritemvalues()
else:
for name, value in dict_.items():
self._outputs[name] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_save_getitemvalues(self) -> None: """Save the values of all current |GetItem| objects.""" |
for item in state.getitems:
for name, value in item.yield_name2value(state.idx1, state.idx2):
state.getitemvalues[self._id][name] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_savedgetitemvalues(self) -> None: """Get the previously saved values of all |GetItem| objects.""" |
dict_ = state.getitemvalues.get(self._id)
if dict_ is None:
self.GET_getitemvalues()
else:
for name, value in dict_.items():
self._outputs[name] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_save_timegrid(self) -> None: """Save the current simulation period.""" |
state.timegrids[self._id] = copy.deepcopy(hydpy.pub.timegrids.sim) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def GET_savedtimegrid(self) -> None: """Get the previously saved simulation period.""" |
try:
self._write_timegrid(state.timegrids[self._id])
except KeyError:
self._write_timegrid(hydpy.pub.timegrids.init) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _compare_variables_function_generator( method_string, aggregation_func):
"""Return a function usable as a comparison method for class |Variable|. Pass the specific method (e.g. `__eq__`) and the corresponding operator (e.g. `==`) as strings. Also pass either |numpy.all| or |numpy.any| for aggregating multiple boolean values. """ |
def comparison_function(self, other):
"""Wrapper for comparison functions for class |Variable|."""
if self is other:
return method_string in ('__eq__', '__le__', '__ge__')
method = getattr(self.value, method_string)
try:
if hasattr(type(other), '__hydpy__get_value__'):
other = other.__hydpy__get_value__()
result = method(other)
if result is NotImplemented:
return result
return aggregation_func(result)
except BaseException:
objecttools.augment_excmessage(
f'While trying to compare variable '
f'{objecttools.elementphrase(self)} with object '
f'`{other}` of type `{objecttools.classname(other)}`')
return comparison_function |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def verify(self) -> None: """Raises a |RuntimeError| if at least one of the required values of a |Variable| object is |None| or |numpy.nan|. The descriptor `mask` defines, which values are considered to be necessary. Example on a 0-dimensional |Variable|: Traceback (most recent call last):
RuntimeError: For variable `var`, 1 required value has not been set yet. Example on a 2-dimensional |Variable|: Traceback (most recent call last):
RuntimeError: For variable `var`, 2 required values \ have not been set yet. Traceback (most recent call last):
RuntimeError: For variable `var`, 1 required value has not been set yet. """ |
nmbnan: int = numpy.sum(numpy.isnan(
numpy.array(self.value)[self.mask]))
if nmbnan:
if nmbnan == 1:
text = 'value has'
else:
text = 'values have'
raise RuntimeError(
f'For variable {objecttools.devicephrase(self)}, '
f'{nmbnan} required {text} not been set yet.') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def average_values(self, *args, **kwargs) -> float: """Average the actual values of the |Variable| object. For 0-dimensional |Variable| objects, the result of method |Variable.average_values| equals |Variable.value|. The following example shows this for the sloppily defined class `SoilMoisture`: 200.0 When the dimensionality of this class is increased to one, applying method |Variable.average_values| results in the following error: Traceback (most recent call last):
AttributeError: While trying to calculate the mean value \ of variable `soilmoisture`, the following error occurred: Variable \ `soilmoisture` does not define any weighting coefficients. So model developers have to define another (in this case 1-dimensional) |Variable| subclass (usually a |Parameter| subclass), and make the relevant object available via property |Variable.refweights|: 400.0 In the examples above, all single entries of `values` are relevant, which is the default case. However, subclasses of |Variable| can define an alternative mask, allowing to make some entries irrelevant. Assume for example, that our `SoilMoisture` object contains three single values, each one associated with a specific hydrological response unit (hru). To indicate that soil moisture is undefined for the third unit, (maybe because it is a water area), we set the third entry of the verification mask to |False|: 300.0 Alternatively, method |Variable.average_values| accepts additional masking information as positional or keyword arguments. Therefore, the corresponding model must implement some alternative masks, which are provided by property |Variable.availablemasks|. We mock this property with a new |Masks| object, handling one mask for flat soils (only the first hru), one mask for deep soils (only the second hru), and one mask for water areas (only the third hru):
One can pass either the mask classes themselves or their names: 200.0 400.0 Both variants can be combined: 300.0 The following error happens if the general mask of the variable does not contain the given masks: Traceback (most recent call last):
ValueError: While trying to calculate the mean value of variable \ `soilmoisture`, the following error occurred: Based on the arguments \ `('flatsoil', 'water')` and `{}` the mask `CustomMask([ True, False, True])` \ has been determined, which is not a submask of `Soil([ True, True, False])`. Applying masks with custom options is also supported. One can change the behaviour of the following mask via the argument `complete`: Again, one can apply the mask class directly (but note that one has to pass the relevant variable as the first argument.):
Traceback (most recent call last):
Alternatively, one can pass the mask name as a keyword and pack the mask's options into a |dict| object: nan You can combine all variants explained above: 300.0 """ |
try:
if not self.NDIM:
return self.value
mask = self.get_submask(*args, **kwargs)
if numpy.any(mask):
weights = self.refweights[mask]
return numpy.sum(weights*self[mask])/numpy.sum(weights)
return numpy.nan
except BaseException:
objecttools.augment_excmessage(
f'While trying to calculate the mean value of variable '
f'{objecttools.devicephrase(self)}') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_submask(self, *args, **kwargs) -> masktools.CustomMask: """Get a sub-mask of the mask handled by the actual |Variable| object based on the given arguments. See the documentation on method |Variable.average_values| for further information. """ |
if args or kwargs:
masks = self.availablemasks
mask = masktools.CustomMask(numpy.full(self.shape, False))
for arg in args:
mask = mask + self._prepare_mask(arg, masks)
for key, value in kwargs.items():
mask = mask + self._prepare_mask(key, masks, **value)
if mask not in self.mask:
raise ValueError(
f'Based on the arguments `{args}` and `{kwargs}` '
f'the mask `{repr(mask)}` has been determined, '
f'which is not a submask of `{repr(self.mask)}`.')
else:
mask = self.mask
return mask |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def commentrepr(self) -> List[str]: """A list with comments for making string representations more informative. With option |Options.reprcomments| being disabled, |Variable.commentrepr| is empty. """ |
if hydpy.pub.options.reprcomments:
return [f'# {line}' for line in
textwrap.wrap(objecttools.description(self), 72)]
return [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.