def inner():
img = ax.imshow([[0, 1], [2, 3]])
cursor = mplcursors.cursor(img)
f_img = weakref.finalize(img, lambda: None)
f_cursor = weakref.finalize(cursor, lambda: None)
img.remove()
return f_img, f_cursor
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._silent = False
# console, qtconsole uses `kernel-$pid`, notebook uses `kernel-$uuid`.
self._has_console_frontend = bool(re.match(
r"\Akernel-\d+\Z",
Path(self.config["IPKernelApp"]["connection_file"]).stem))
if os.name == "posix":
with ExitStack() as stack:
for name in ["stdout", "stderr"]:
stream = getattr(sys, "__{}__".format(name))
def callback(data, *, _name=name, _stream=stream):
if not self._silent:
self._send_stream(
_name, data.decode(_stream.encoding))
stack.enter_context(
_redirection.redirect(stream.fileno(), callback))
weakref.finalize(self, stack.pop_all().close)
self._dead_engines = []
engine_name = os.environ.get("IMATLAB_CONNECT")
if engine_name:
if re.match(r"\A(?a)[a-zA-Z]\w*\Z", engine_name):
self._engine = matlab.engine.connect_matlab(engine_name)
else:
self._engine = matlab.engine.connect_matlab()
else:
self._engine = matlab.engine.start_matlab()
self._history = MatlabHistory(Path(self._call("prefdir")))
self._engine.addpath(
str(Path(sys.modules[__name__.split(".")[0]].__file__).
with_name("data")),
"-end")
def __init__(self):
conn_parent, conn_child = mp.Pipe()
# Use a local variable for child so that we can talk to the child in
# on_finalize without needing a reference to self
child = mp.Process(target=_converter_process_func, args=(conn_parent, conn_child))
child.daemon = True
child.start()
self.child = child
conn_child.close()
self.conn = conn_parent
self.busy = False
self.conversionNotifier = QSocketNotifier(self.conn.fileno(),
QSocketNotifier.Read)
# assign the activated signal of the notifier to a conversionDone
# member to get a more meaningful signal name for others to connect to
self.conversionDone = self.conversionNotifier.activated
def on_finalize(conn):
conn_parent.send({'command':'quit'})
conn_parent.close()
child.join()
weakref.finalize(self, on_finalize, conn_parent)
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
"""
Connect receiver to sender for signal.
Arguments:
receiver
A function or an instance method which is to receive signals.
Receivers must be hashable objects.
If weak is True, then receiver must be weak referenceable.
Receivers must be able to accept keyword arguments.
If a receiver is connected with a dispatch_uid argument, it
will not be added if another receiver was already connected
with that dispatch_uid.
sender
The sender to which the receiver should respond. Must either be
of type Signal, or None to receive events from any sender.
weak
Whether to use weak references to the receiver. By default, the
module will attempt to use weak references to the receiver
objects. If this parameter is false, then strong references will
be used.
dispatch_uid
An identifier used to uniquely identify a particular instance of
a receiver. This will usually be a string, though it may be
anything hashable.
"""
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
if weak:
ref = weakref.ref
receiver_object = receiver
# Check for bound methods
if hasattr(receiver, '__self__') and hasattr(receiver, '__func__'):
ref = WeakMethod
receiver_object = receiver.__self__
if six.PY3:
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
def initializeGL(self):
print('initialize GL')
if self._get_proc_address is 'ctypes':
import ctypes,ctypes.util
lgl = ctypes.cdll.LoadLibrary(ctypes.util.find_library('GL'))
get_proc_address = lgl.glXGetProcAddress
get_proc_address.restype = ctypes.c_void_p
get_proc_address.argtypes = [ ctypes.c_char_p ]
_get_proc_address = lambda name: get_proc_address(name if isinstance(name,bytes) else name.encode('latin1'))
else:
qgl_get_proc_address = Q.QGLContext.currentContext().getProcAddress
_get_proc_address = lambda name: int(qgl_get_proc_address(name.decode('latin1') if isinstance(name,bytes) else name))
if self._get_proc_address_debug:
def getprocaddr(name):
res = _get_proc_address(name)
print('{} -> address {}'.format(name,res))
return res
else:
getprocaddr = _get_proc_address
self.ogl = self.m.opengl_cb_context
self.ogl.init_gl(getprocaddr,None)
weakref.finalize(self, lambda:self.ogl.set_update_callback(None))
self.wakeup.connect(self.onWakeup,Q.Qt.QueuedConnection|Q.Qt.UniqueConnection)
self.frameSwapped.connect(self.onFrameSwapped)
self.ogl.set_update_callback(self.wakeup.emit)
self.openglInitialized.emit(Q.QOpenGLContext.currentContext())
def __init__(self,name=None,dir='/tmp',text=False,encoding=None, expires=None):
if name is None:
fd,path = tempfile.mkstemp(suffix='.tmp',dir=dir,text=False)
else:
path = os.path.join(dir,name)
if os.path.exists(path) and ((expires is None) or (time.time() + expires > os.stat(path).st_mtime)):
self.new = False
else:
path = path + '.tmp'
encoding = encoding if encoding else 'utf-8' if text else None
self.name = path
if name is not None:
mode = 'w+' if self.new else 'r+'
mode += 't' if text else 'b'
self.file = open(path, mode, encoding=encoding)
if encoding or text:
self.raw = self.file.raw
else:
self.raw = self.file
else:
self.raw = os.fdopen(fd,'w+b')
if encoding:
if encoding is True:
encoding = 'utf-8'
self.file = io.TextIOWrapper(self.raw,encoding=encoding)
else:
self.file = self.raw
weakref.finalize(self, self.ifnew, os.unlink, path)
def __init__(self):
super(QObject, self).__init__()
conn_parent, conn_child = socketpair()
# TODO: figure out which of the two sockets should be set to
# inheritable and which should be passed to the child
if hasattr(conn_child, 'set_inheritable'):
conn_child.set_inheritable(True)
# Use a local variable for child so that we can talk to the child in
# on_finalize without needing a reference to self
child = mp.Process(target=_converter_process_func, args=(conn_parent, conn_child))
child.daemon = True
child.start()
self.child = child
conn_child.close()
self.conn = conn_parent
self.busy = False
self.notificationPending = False
self.conversionNotifier = QSocketNotifier(self.conn.fileno(),
QSocketNotifier.Read)
self.conversionNotifier.activated.connect(self._conversionNotifierActivated)
def on_finalize(conn):
sendObject(conn_parent, {'command':'quit'})
conn_parent.close()
child.join()
weakref.finalize(self, on_finalize, conn_parent)
def _connect_signal(self, receiver, sender, weak, dispatch_uid):
assert callable(receiver), 'Signal receivers must be callable'
if not fun_accepts_kwargs(receiver):
raise ValueError(
'Signal receiver must accept keyword arguments.')
if isinstance(sender, PromiseProxy):
sender.__then__(
self._connect_proxy, receiver, sender, weak, dispatch_uid,
)
return receiver
lookup_key = _make_lookup_key(receiver, sender, dispatch_uid)
if weak:
ref, receiver_object = _boundmethod_safe_weakref(receiver)
if PY3:
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
return receiver
def __init__(self, username=None, password=None):
self._username = self._remove_nonascii(username)
self._password = self._remove_nonascii(password)
self.logger.info('Initialized with user: %s', self._username)
self.session = Session()
# urllib3 will sleep for {backoff factor} * (2 ^ ({number of total retries} - 1)) seconds between attempts.
self.session.mount('http://', HTTPAdapter(
max_retries=Retry(total=2, backoff_factor=0.5, status_forcelist=[500, 502, 503, 504])
))
self.session.mount('https://', HTTPAdapter(
max_retries=Retry(total=2, backoff_factor=0.5, status_forcelist=[500, 502, 503, 504])
))
self.set_useragent()
# Avoid ResourceWarning: unclosed <ssl.SSLSocket ...> with python 3
finalize(self, self.session.close)
cookie_file = os.path.join(self.appdata_path, self._make_fs_safe(username)+'.lwp')
self.session.cookies = LWPCookieJar(cookie_file)
if not os.path.exists(cookie_file):
# initialize new cookie file
self.logger.info('Creating new cookie file: "%s"', cookie_file)
self.set_mobile_cookies()
self._save_cookies()
os.chmod(cookie_file, stat.S_IRUSR | stat.S_IWUSR)
else:
# load cookies
self.logger.info('Loading cookies from file: "%s"', cookie_file)
self.session.cookies.load(ignore_discard=True)
if not self._has_cookie('forceMobile') or not self._has_cookie('mobileClient'):
self.clear_mobile_cookies()
self.set_mobile_cookies()
self._save_cookies()
def __init__(self, handler):
_path = msg.join_path(self._path, '__init__')
self.handler = handler
self.pub_subs = {
'w': self.handler.ws_pub_sub,
'd': mb,
'l': self.handler.local_pub_sub,
}
for attr_name in dir(self):
attribute = getattr(self, attr_name)
if hasattr(attribute, 'msg_types'):
for _type, channels in attribute.msg_types:
msg.code_debug(
_path,
'Adding action: %r ...' % attribute
)
self.register_action_in(
msg_type=_type, action=attribute,
channels=channels)
finalize(
self, msg.code_debug, self._path,
'Deleting WSClass {0} from {0.handler} '
'...'.format(self)
)
def _delete_widget(self, widget):
"""
Delete the OWBaseWidget instance.
"""
widget.close()
# Save settings to user global settings.
widget.saveSettings()
# Notify the widget it will be deleted.
widget.onDeleteWidget()
state = self.__widget_processing_state[widget]
if state & WidgetManager._DelayDeleteMask:
# If the widget is in an update loop and/or blocking we
# delay the scheduled deletion until the widget is done.
log.debug("Widget %s removed but still in state :%s. "
"Deferring deletion.", widget, state)
self.__delay_delete.add(widget)
else:
widget.deleteLater()
name = "{} '{}'".format(type(widget).__name__, widget.captionTitle)
if log.isEnabledFor(logging.DEBUG):
finalize(
widget, log.debug, "Destroyed namespace: %s", name
)
del self.__widget_processing_state[widget]
def __init__(
self,
scidb_url=None,
scidb_auth=None,
http_auth=None,
verify=None,
admin=False,
namespace=None,
use_arrow=False,
result_size_limit=256,
no_ops=False):
if scidb_url is None:
scidb_url = os.getenv('SCIDB_URL', 'http://localhost:8080')
self.scidb_url = scidb_url
self.verify = verify
self.admin = admin
self.namespace = namespace
self.use_arrow = use_arrow
self.result_size_limit = result_size_limit
self.no_ops = no_ops
if http_auth:
self._http_auth = requests.auth.HTTPDigestAuth(*http_auth)
self.http_auth = (http_auth[0], Password_Placeholder())
else:
self._http_auth = self.http_auth = None
admin_shim = 1 if self.admin else 0
if scidb_auth:
self._id = self._shim(Shim.new_session,
user=scidb_auth[0],
password=scidb_auth[1],
admin=admin_shim).text
self.scidb_auth = (scidb_auth[0], Password_Placeholder())
else:
self._id = self._shim(Shim.new_session,
admin=admin_shim).text
self.scidb_auth = None
finalize(self,
_shim_release_session,
self.scidb_url,
self._http_auth,
self.verify,
self._id)
self.arrays = Arrays(self)
self._uid = uuid.uuid1().hex
self._lock = threading.Lock()
self._array_cnt = 0
self._formatter = string.Formatter()
if self.no_ops:
self.operators = None
self._dir = None
else:
self.load_ops()
def __init__(self, title, width, height):
self.win = SDL_CreateWindow(title.encode('utf-8'), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
width, height, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE)
weakref.finalize(self.win, SDL_DestroyWindow, self.win)
self.dirtyRects = []
self.width = width
self.height = height
self.scale = 1
def watch(self,action,done):
self.action = action
self.done = done
if self.cancelled:
done.add_done_callback(self.nocancel)
weakref.finalize(self,self.cancel)
self.cancelled = False
return done
def __init__(self, db, name, gc=False):
self.db = db
self.name = name
if gc:
finalize(self,
self.db.iquery,
'remove({})'.format(self.name))
def __new__(cls, filename):
if filename in AdvConfig._configs:
n=AdvConfig._configs[filename]
n.sync()
else:
n=super(AdvConfig,cls).__new__(cls)
AdvConfig._configs[filename]=n
finalize(n, n.sync)
return n
def _get_properties(self, request):
req_id = id(request)
if req_id in self._request_properties:
return self._request_properties[req_id]
else:
finalize(request, self._free_properties, req_id)
properties = {}
self._request_properties[req_id] = properties
return properties
def __init__(self, service):
super().__init__(service)
logging.getLogger("chardet").setLevel(logging.WARNING)
self.common_loop = service.loop
self.common_connector = TCPConnector(limit=GET_URL_PARALLEL_LIMIT, loop=self.common_loop)
self.common_cookie_jar = self.new_cookie_jar()
self.common_client_timeout = aiohttp.ClientTimeout(sock_connect=GET_URL_CONNECT_TIMEOUT,
sock_read=GET_URL_RECV_TIMEOUT)
logging.debug("init %s" % self.common_connector)
weakref.finalize(self, _close_connector, self.common_loop, self.common_connector)
def __init__(self, path):
self.surfacePtr = IMG_Load(path.encode("utf-8"))
if not self.surfacePtr:
raise FileNotFoundError(path)
weakref.finalize(self.surfacePtr, SDL_FreeSurface, self.surfacePtr)
self.xScale = 1
self.yScale = 1
def __init__(self, filename): ''' Read contents of dictionary from file, set up deletion hook ''' self.filename = filename dict.__init__(self) try: with open(self.filename, 'rb') as cache_file: self.update(load(cache_file)) except FileNotFoundError: pass # on read, don't create the file if it does not exist # when object is deleted, update file finalize(self, lambda: self.dump_to_file())
def register_injector(cls, instance, injector):
"""Registers the injector for a specific instance, using weak references.
Arguments
---------
instance: any
an arbitrary object
injector: Injector
the injector to be used
"""
cls.INSTANCE_REGISTRY[id(instance)] = injector
weakref.finalize(instance, lambda: cls.INSTANCE_REGISTRY.pop(id(instance)))
def __init__(self, parent):
self.parent = parent
self.__methods = []
if self.__options__:
self.__config = Config(
self.__class__.__gsettings__.get("schema"),
self.__class__.__gsettings__.get("path")
)
weakref.finalize(self, self._on_plugin_delete)
def __init__(self):
super().__init__()
self.__transfers = {}
self.__signals = []
self._object_manager = Gio.DBusObjectManagerClient.new_for_bus_sync(
Gio.BusType.SESSION, Gio.DBusObjectManagerClientFlags.NONE,
self.__bus_name, '/', None, None, None)
self.__signals.append(self._object_manager.connect('object-added', self._on_object_added))
self.__signals.append(self._object_manager.connect('object-removed', self._on_object_removed))
weakref.finalize(self, self._on_delete)
def __init__(self, defer_atexit=False):
"""Constructor.
:param bool defer_atexit: cleanup() to atexit instead of after garbage collection.
"""
self.name = tempfile.mkdtemp('sphinxcontrib_versioning')
if defer_atexit:
atexit.register(shutil.rmtree, self.name, True)
return
try:
weakref.finalize(self, shutil.rmtree, self.name, True)
except AttributeError:
weakref.proxy(self, functools.partial(shutil.rmtree, self.name, True))
def __lookup_single(cls, o):
if o is None:
return None
cache = cls.__minidb_cache__
if o.id not in cache:
if DEBUG_OBJECT_CACHE:
logger.debug('Storing id={} in cache {}'.format(o.id, o))
weakref.finalize(o, cls._finalize, o.id)
cache[o.id] = o
else:
if DEBUG_OBJECT_CACHE:
logger.debug('Getting id={} from cache'.format(o.id))
return cache[o.id]
def save(self, db=None):
if getattr(self, Store.MINIDB_ATTR, None) is None:
if db is None:
raise ValueError('Needs a db object')
setattr(self, Store.MINIDB_ATTR, db)
getattr(self, Store.MINIDB_ATTR).save_or_update(self)
if DEBUG_OBJECT_CACHE:
logger.debug('Storing id={} in cache {}'.format(self.id, self))
weakref.finalize(self, self.__class__._finalize, self.id)
self.__class__.__minidb_cache__[self.id] = self
return self
def bore(self):
"""Create SSH tunnel from given context."""
cmd = ['ssh', '-fNT']
if logging.getLogger().getEffectiveLevel() == logging.DEBUG:
cmd.append('-v')
else:
cmd.append('-q')
if self.context.port:
cmd.extend(('-p', str(self.context.port)))
cmd.extend(('-L', '{}:{}'.format(self.context.local_socket,
self.context.remote_socket)))
if self.context.identity_file:
cmd.extend(('-i', self.context.identity_file))
cmd.append('{}@{}'.format(self.context.username,
self.context.hostname))
logging.debug('Opening tunnel "%s", cmd "%s"', self.context.uri,
' '.join(cmd))
tunnel = subprocess.Popen(cmd, close_fds=True)
# The return value of Popen() has no long term value as that process
# has already exited by the time control is returned here. This is a
# side effect of the -f option. wait() will be called to clean up
# resources.
for _ in range(300):
# TODO: Make timeout configurable
if os.path.exists(self.context.local_socket) \
or tunnel.returncode is not None:
break
with suppress(subprocess.TimeoutExpired):
# waiting for either socket to be created
# or first child to exit
tunnel.wait(0.5)
else:
raise TimeoutError(
'Failed to create tunnel "{}", using: "{}"'.format(
self.context.uri, ' '.join(cmd)))
if tunnel.returncode is not None and tunnel.returncode != 0:
raise subprocess.CalledProcessError(tunnel.returncode,
' '.join(cmd))
tunnel.wait()
self._closed = False
weakref.finalize(self, self.close)
return self
def connect(self, receiver):
# Check for bound methods
if hasattr(receiver, "__self__") and hasattr(receiver, "__func__"):
ref = weakref.WeakMethod
receiver_object = receiver.__self__
else:
ref = weakref.ref
receiver_object = receiver
receiver_ref = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
with self._lock:
self._clear_dead_receivers()
if receiver not in self._receivers:
self._receivers.append(receiver_ref)
def __new__(cls, *args, **kwargs):
"""Creates a new object instance and adds the private finalizer
attributes to it.
Returns: new object instance
Arguments:
* *args, **kwargs -- passed to the parent instance creator
(which ignores them)
"""
# Note: Do not pass a (hard) reference to instance to the
# finalizer as func/args/kwargs, it'd keep the object
# alive until the program terminates.
# A weak reference is fine.
#
# Note 2: When using weakrefs and not calling finalize() in
# __del__, the object may already have disappeared
# when weakref.finalize() kicks in.
# Make sure that _finalizer() gets called,
# i.e. keep __del__() from the base class.
#
# Note 3: the _finalize_called attribute is (probably) useless
# for this class
instance = super(AutoFinalizedObject, cls).__new__(
cls, *args, **kwargs
)
instance._finalizer = weakref.finalize(
instance, _do_finalize_object_ref, weakref.ref(instance)
)
return instance
def __init__(self, port, simPort=None):
"""Constructor
:param port: the physical SPI port
:type port: :class:`.SPI.Port`
:param simPort: This must be an object that implements all of
the spi* functions from hal_impl that you use.
See ``test_spi.py`` for an example.
"""
if hal.HALIsSimulation():
if simPort is None:
raise ValueError("You will need to use a mock for this SPI port, or provide a simPort implementation")
# Just check for basic functionality
assert hasattr(simPort, 'spiInitialize')
assert hasattr(simPort, 'spiClose')
self._port = (simPort, port)
else:
self._port = port
self.bitOrder = 0
self.clockPolarity = 0
self.dataOnTrailing = 0
hal.spiInitialize(self._port)
self.__finalizer = weakref.finalize(self, _freeSPI, self._port)
SPI.devices += 1
hal.HALReport(hal.HALUsageReporting.kResourceType_SPI, SPI.devices)
def numba_device_array(n):
a = numba.cuda.device_array((n,), dtype="u1")
weakref.finalize(a, numba.cuda.current_context)
return a
def __init__(self):
self._finalizer = weakref.finalize(self, self.close_connection)
def __init__(self, *args, **kwargs):
"""Counter constructor.
The counter will start counting immediately.
Positional arguments may be either channel numbers, :class:`.DigitalSource`
sources, or :class:`.AnalogTrigger` sources in the following order:
A "source" is any valid single-argument input to :meth:`setUpSource` and :meth:`setDownSource`
- (none)
- upSource
- upSource, down source
And, to keep consistency with Java wpilib.
- encodingType, up source, down source, inverted
If the passed object has a
`getPortHandleForRouting` function, it is assumed to be a DigitalSource.
If the passed object has a `createOutput` function, it is assumed to
be an AnalogTrigger.
In addition, extra keyword parameters may be provided for mode, inverted,
and encodingType.
:param upSource: The source (channel num, DigitalInput, or AnalogTrigger)
that should be used for up counting.
:param downSource: The source (channel num, DigitalInput, or AnalogTrigger)
that should be used for down counting or direction control.
:param mode:
How and what the counter counts (see :class:`.Mode`). Defaults to
`Mode.kTwoPulse` for zero or one source, and
`Mode.kExternalDirection` for two sources.
:param inverted:
Flips the direction of counting. Defaults to False if unspecified.
Only used when two sources are specified.
:param encodingType:
Either k1X or k2X to indicate 1X or 2X decoding. 4X decoding
is not supported by Counter; use `Encoder` instead. Defaults
to k1X if unspecified. Only used when two sources are specified.
:type encodingType: :class:`.Counter.EncodingType`
"""
source_identifier = [int, HasAttribute("getPortHandleForRouting"), HasAttribute("createOutput")]
argument_templates = [[],
[("upSource", source_identifier), ],
[("upSource", source_identifier), ("downSource", source_identifier)],
[("encodingType", None), ("upSource", source_identifier),
("downSource", source_identifier), ("inverted", bool)], ]
_, results = match_arglist('Counter.__init__',
args, kwargs, argument_templates, allow_extra_kwargs=True)
# extract arguments
upSource = results.pop("upSource", None)
downSource = results.pop("downSource", None)
encodingType = results.pop("encodingType", None)
inverted = results.pop("inverted", False)
mode = results.pop("mode", None)
if mode is None:
#Get the mode
if upSource is not None and downSource is not None:
mode = self.Mode.kExternalDirection
else:
mode = self.Mode.kTwoPulse
# save some variables
self.distancePerPulse = 1.0 # distance of travel for each tick
self.pidSource = self.PIDSourceType.kDisplacement
# create counter
self._counter, self.index = hal.initializeCounter(mode)
self.__finalizer = \
weakref.finalize(self, _freeCounter, self)
self.setMaxPeriod(.5)
hal.report(hal.UsageReporting.kResourceType_Counter, self.index, mode)
# Set sources
if upSource is not None:
self.setUpSource(upSource)
else:
self.upSource = None
if downSource is not None:
self.setDownSource(downSource)
else:
self.downSource = None
# when given two sources, set edges
if upSource is not None and downSource is not None:
if encodingType == self.EncodingType.k1X:
self.setUpSourceEdge(True, False)
hal.setCounterAverageSize(self._counter, 1)
else:
self.setUpSourceEdge(True, True)
hal.setCounterAverageSize(self._counter, 2)
self.setDownSourceEdge(inverted, True)
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
"""
Connect receiver to sender for signal.
Arguments:
receiver
A function or an instance method which is to receive signals.
Receivers must be hashable objects.
If weak is True, then receiver must be weak referenceable.
Receivers must be able to accept keyword arguments.
If a receiver is connected with a dispatch_uid argument, it
will not be added if another receiver was already connected
with that dispatch_uid.
sender
The sender to which the receiver should respond. Must either be
of type Signal, or None to receive events from any sender.
weak
Whether to use weak references to the receiver. By default, the
module will attempt to use weak references to the receiver
objects. If this parameter is false, then strong references will
be used.
dispatch_uid
An identifier used to uniquely identify a particular instance of
a receiver. This will usually be a string, though it may be
anything hashable.
"""
#from django.conf import settings
# If DEBUG is on, check that we got a good receiver
if pysignals_debug:
import inspect
assert callable(receiver), "Signal receivers must be callable."
# Check for **kwargs
if not func_accepts_kwargs(receiver):
raise ValueError(
"Signal receivers must accept keyword arguments (**kwargs)."
)
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
if weak:
ref = weakref.ref
receiver_object = receiver
# Check for bound methods
if hasattr(receiver, '__self__') and hasattr(receiver, '__func__'):
ref = WeakMethod
receiver_object = receiver.__self__
if six.PY3:
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
def insert(self, obj: Any, node: ANFNode) -> None:
"""Add a mapping in the environement, rejecting duplicates."""
assert id(obj) not in self._object_map
self._object_map[id(obj)] = node
finalize(obj, self._remove, id(obj))
def __new(cls, *args):
self = super().__new__(cls, *args)
self._destructor = weakref.finalize(self, self._destruct, str(self))
return self
def numba_cuda_array(n):
a = numba.cuda.device_array((n, ), dtype=np.uint8)
weakref.finalize(a, numba.cuda.current_context)
return a
def __init__(self,
pod_template=None,
name=None,
namespace=None,
n_workers=None,
host=None,
port=None,
env=None,
**kwargs):
name = name or dask.config.get('kubernetes.name')
namespace = namespace or dask.config.get('kubernetes.namespace')
n_workers = n_workers if n_workers is not None else dask.config.get(
'kubernetes.count.start')
host = host or dask.config.get('kubernetes.host')
port = port if port is not None else dask.config.get('kubernetes.port')
env = env if env is not None else dask.config.get('kubernetes.env')
if not pod_template and dask.config.get('kubernetes.worker-template',
None):
d = dask.config.get('kubernetes.worker-template')
d = dask.config.expand_environment_variables(d)
pod_template = make_pod_from_dict(d)
if not pod_template and dask.config.get(
'kubernetes.worker-template-path', None):
import yaml
fn = dask.config.get('kubernetes.worker-template-path')
fn = fn.format(**os.environ)
with open(fn) as f:
d = yaml.safe_load(f)
d = dask.config.expand_environment_variables(d)
pod_template = make_pod_from_dict(d)
if not pod_template:
msg = ("Worker pod specification not provided. See KubeCluster "
"docstring for ways to specify workers")
raise ValueError(msg)
self.cluster = LocalCluster(ip=host or socket.gethostname(),
scheduler_port=port,
n_workers=0,
**kwargs)
try:
kubernetes.config.load_incluster_config()
except kubernetes.config.ConfigException:
kubernetes.config.load_kube_config()
self.core_api = kubernetes.client.CoreV1Api()
if namespace is None:
namespace = _namespace_default()
name = name.format(user=getpass.getuser(),
uuid=str(uuid.uuid4())[:10],
**os.environ)
name = escape(name)
self.pod_template = clean_pod_template(pod_template)
# Default labels that can't be overwritten
self.pod_template.metadata.labels['dask.org/cluster-name'] = name
self.pod_template.metadata.labels['user'] = escape(getpass.getuser())
self.pod_template.metadata.labels['app'] = 'dask'
self.pod_template.metadata.labels['component'] = 'dask-worker'
self.pod_template.metadata.namespace = namespace
self.pod_template.spec.containers[0].env.append(
kubernetes.client.V1EnvVar(name='DASK_SCHEDULER_ADDRESS',
value=self.scheduler_address))
if env:
self.pod_template.spec.containers[0].env.extend([
kubernetes.client.V1EnvVar(name=k, value=str(v))
for k, v in env.items()
])
self.pod_template.metadata.generate_name = name
finalize(self, _cleanup_pods, self.namespace,
self.pod_template.metadata.labels)
if n_workers:
self.scale(n_workers)
For use in finalizers, __del__ methods, and similar; it is advised
to early bind this function rather than look it up when calling it,
since at shutdown module globals may be cleared.
"""
# At shutdown, the attribute may have been cleared or set to None.
v = globals().get('_shutting_down')
return v is True or v is None
# weakref.finalize registers an exit function that runs all finalizers for
# which atexit is True. Some of these finalizers may call shutting_down() to
# check whether the interpreter is shutting down. For this to behave correctly,
# we need to make sure that _at_shutdown is called before the finalizer exit
# function. Since atexit operates as a LIFO stack, we first contruct a dummy
# finalizer then register atexit to ensure this ordering.
weakref.finalize(lambda: None, lambda: None)
atexit.register(_at_shutdown)
class ConfigStack:
"""A stack for tracking target configurations in the compiler.
It stores the stack in a thread-local class attribute. All instances in the
same thread will see the same stack.
"""
tls = threading.local()
def __init__(self):
tls = self.tls
try:
stk = tls.stack
def __init__(self, permutation: List[int], sector: int):
"""Create a symmetry given a `permutation` of sites and `sector` specifying the eigenvalue."""
self._payload = _create_symmetry(permutation, sector)
self._finalizer = weakref.finalize(self,
_destroy(_lib.ls_destroy_symmetry),
self._payload)
async def _start(self):
self._generate_name = self._generate_name or dask.config.get(
"kubernetes.name")
self._namespace = self._namespace or dask.config.get(
"kubernetes.namespace")
self._idle_timeout = self._idle_timeout or dask.config.get(
"kubernetes.idle-timeout")
self._scheduler_service_wait_timeout = (
self._scheduler_service_wait_timeout
or dask.config.get("kubernetes.scheduler-service-wait-timeout"))
self._deploy_mode = self._deploy_mode or dask.config.get(
"kubernetes.deploy-mode")
self._n_workers = (self._n_workers if self._n_workers is not None else
dask.config.get("kubernetes.count.start"))
self.host = self.host or dask.config.get("kubernetes.host")
self.port = (self.port if self.port is not None else
dask.config.get("kubernetes.port"))
self._protocol = self._protocol or dask.config.get(
"kubernetes.protocol")
self._interface = self._interface or dask.config.get(
"kubernetes.interface")
self._dashboard_address = self._dashboard_address or dask.config.get(
"kubernetes.dashboard_address")
self.env = (self.env if self.env is not None else
dask.config.get("kubernetes.env"))
if not self.pod_template and dask.config.get(
"kubernetes.worker-template", None):
d = dask.config.get("kubernetes.worker-template")
d = dask.config.expand_environment_variables(d)
self.pod_template = make_pod_from_dict(d)
if not self.pod_template and dask.config.get(
"kubernetes.worker-template-path", None):
import yaml
fn = dask.config.get("kubernetes.worker-template-path")
fn = fn.format(**os.environ)
with open(fn) as f:
d = yaml.safe_load(f)
d = dask.config.expand_environment_variables(d)
self.pod_template = make_pod_from_dict(d)
if not self.pod_template:
msg = ("Worker pod specification not provided. See KubeCluster "
"docstring for ways to specify workers")
raise ValueError(msg)
self.pod_template = clean_pod_template(self.pod_template)
await ClusterAuth.load_first(self.auth)
self.core_api = kubernetes.client.CoreV1Api()
if self._namespace is None:
self._namespace = _namespace_default()
self._generate_name = self._generate_name.format(
user=getpass.getuser(), uuid=str(uuid.uuid4())[:10], **os.environ)
self._generate_name = escape(self._generate_name)
# Default labels that can't be overwritten
self.pod_template.metadata.labels[
"dask.org/cluster-name"] = self._generate_name
self.pod_template.metadata.labels["user"] = escape(getpass.getuser())
self.pod_template.metadata.labels["app"] = "dask"
self.pod_template.metadata.namespace = self._namespace
if self.env:
self.pod_template.spec.containers[0].env.extend([
kubernetes.client.V1EnvVar(name=k, value=str(v))
for k, v in self.env.items()
])
self.pod_template.metadata.generate_name = self._generate_name
finalize(self, _cleanup_resources, self._namespace,
self.pod_template.metadata.labels)
common_options = {
"core_api": self.core_api,
"pod_template": self.pod_template,
"namespace": self._namespace,
"loop": self.loop,
}
if self._deploy_mode == "local":
self.scheduler_spec = {
"cls": dask.distributed.Scheduler,
"options": {
"protocol": self._protocol,
"interface": self._interface,
"host": self.host,
"port": self.port,
"dashboard_address": self._dashboard_address,
"security": self.security,
},
}
elif self._deploy_mode == "remote":
self.scheduler_spec = {
"cls": Scheduler,
"options": {
"idle_timeout": self._idle_timeout,
"service_wait_timeout_s":
self._scheduler_service_wait_timeout,
**common_options,
},
}
else:
raise RuntimeError("Unknown deploy mode %s" % self._deploy_mode)
self.new_spec = {"cls": Worker, "options": {**common_options}}
self.worker_spec = {i: self.new_spec for i in range(self._n_workers)}
await super()._start()
def load_lib(self):
self._lib = npct.load_library(self.lib_file, '.')
self._function = self._lib.particle_loop
self._cleanup_lib = finalize(self, cleanup_unload_lib, self._lib)
def __init__(self, generators: List[Symmetry]):
"""Construct a symmetry group from a list of generators."""
self._payload = _create_group(generators)
self._finalizer = weakref.finalize(self,
_destroy(_lib.ls_destroy_group),
self._payload)
def __init__(self, *args, **kwargs):
"""Constructor.
Arguments can be supplied as positional or keyword. Acceptable
positional argument combinations are:
- forwardChannel, reverseChannel
- moduleNumber, forwardChannel, reverseChannel
Alternatively, the above names can be used as keyword arguments.
:param moduleNumber: The module number of the solenoid module to use.
:param forwardChannel: The forward channel number on the module to control (0..7)
:param reverseChannel: The reverse channel number on the module to control (0..7)
"""
# keyword arguments
forwardChannel = kwargs.pop("forwardChannel", None)
reverseChannel = kwargs.pop("reverseChannel", None)
moduleNumber = kwargs.pop("moduleNumber", None)
if kwargs:
warnings.warn("unknown keyword arguments: %s" % kwargs.keys(),
RuntimeWarning)
# positional arguments
if len(args) == 2:
forwardChannel, reverseChannel = args
elif len(args) == 3:
moduleNumber, forwardChannel, reverseChannel = args
elif len(args) != 0:
raise ValueError(
"don't know how to handle %d positional arguments" % len(args))
if moduleNumber is None:
moduleNumber = SensorUtil.getDefaultSolenoidModule()
if forwardChannel is None:
raise ValueError("must specify forward channel")
if reverseChannel is None:
raise ValueError("must specify reverse channel")
super().__init__(moduleNumber)
self.valueEntry = None
SensorUtil.checkSolenoidModule(moduleNumber)
SensorUtil.checkSolenoidChannel(forwardChannel)
SensorUtil.checkSolenoidChannel(reverseChannel)
portHandle = hal.getPortWithModule(moduleNumber, forwardChannel)
self.forwardHandle = hal.initializeSolenoidPort(portHandle)
try:
portHandle = hal.getPortWithModule(moduleNumber, reverseChannel)
self.reverseHandle = hal.initializeSolenoidPort(portHandle)
except Exception:
# free the forward handle on exception, then rethrow
hal.freeSolenoidPort(self.forwardHandle)
self.forwardHandle = None
self.reverseHandle = None
raise
self.forwardMask = 1 << forwardChannel
self.reverseMask = 1 << reverseChannel
# Need this to free on unit test wpilib reset
Resource._add_global_resource(self)
hal.report(hal.UsageReporting.kResourceType_Solenoid, forwardChannel,
moduleNumber)
hal.report(hal.UsageReporting.kResourceType_Solenoid, reverseChannel,
moduleNumber)
self.setName("DoubleSolenoid", moduleNumber, forwardChannel)
self.__finalizer = weakref.finalize(self, _freeSolenoid,
self.forwardHandle,
self.reverseHandle)
def rmm_cuda_array(n):
a = rmm.device_array(n, dtype=np.uint8)
weakref.finalize(a, numba.cuda.current_context)
return a
async def start(self):
assert self.connection
weakref.finalize(
self, self.proc.kill
) # https://github.com/ronf/asyncssh/issues/112
await super().start()
def _setup_finalizer(self):
# pylint: disable=E1101
self.__class__._finalizers.append(
weakref.finalize(self, _finalize_tmpdir, weakref.ref(self)))
#*************************************************************************# # File Name: testweakref.py # Author: yoghourt->ilvcr # Mail: [email protected] @@ [email protected] # Created Time: Thu Mar 28 20:02:41 2019 # Description: #************************************************************************# # error import weakref s1 = {1, 2, 3} s2 = s1 def bye(): print 'Gone with the wind...' ender = weakref.finalize(s1, bye) print '----------------------------------------------\n\n' print ender.alive print '\n\n----------------------------------------------' del s1 print ender.alive
def __init__(
self,
savedir="",
archivefile="nethack.%(pid)i.%(time)s.zip",
character="mon-hum-neu-mal",
max_episode_steps=5000,
observation_keys=(
"glyphs",
"chars",
"colors",
"specials",
"blstats",
"message",
"inv_glyphs",
"inv_strs",
"inv_letters",
"inv_oclasses",
"screen_descriptions",
),
actions=None,
options=None,
wizard=False,
allow_all_yn_questions=False,
):
"""Constructs a new NLE environment.
Args:
savedir (str or None): path to save ttyrecs (game recordings) into.
Defaults to "" (empty string), which makes NLE chose the
directory name. If None, don't save any data. Otherwise,
interpreted as a path to a new or existing directory.
character (str): name of character. Defaults to "mon-hum-neu-mal".
max_episode_steps (int): maximum amount of steps allowed before the
game is forcefully quit. In such cases, ``info["end_status"]``
will be equal to ``StepStatus.ABORTED``. Defaults to 5000.
observation_keys (list): keys to use when creating the observation.
Defaults to all.
actions (list): list of actions. If None, the full action space will
be used, i.e. ``nle.nethack.ACTIONS``. Defaults to None.
options (list): list of game options to initialize Nethack. If None,
Nethack will be initialized with the options found in
``nle.nethack.NETHACKOPTIONS`. Defaults to None.
wizard (bool): activate wizard mode. Defaults to False.
allow_all_yn_questions (bool):
If set to True, no y/n questions in step() are declined.
If set to False, only elements of SKIP_EXCEPTIONS are not declined.
Defaults to False.
"""
self.character = character
self._max_episode_steps = max_episode_steps
self._allow_all_yn_questions = allow_all_yn_questions
if actions is None:
actions = FULL_ACTIONS
self._actions = actions
self.last_observation = None
try:
if savedir is None:
self.savedir = None
self._stats_file = None
self._stats_logger = None
elif savedir:
self.savedir = os.path.abspath(savedir)
os.makedirs(self.savedir)
else: # Empty savedir: We create our unique savedir inside nle_data/.
parent_dir = os.path.join(os.getcwd(), "nle_data")
os.makedirs(parent_dir, exist_ok=True)
self.savedir = tempfile.mkdtemp(
prefix=time.strftime("%Y%m%d-%H%M%S_"), dir=parent_dir)
except FileExistsError:
logger.info("Using existing savedir: %s", self.savedir)
else:
if self.savedir:
logger.info("Created savedir: %s", self.savedir)
else:
logger.info("Not saving any NLE data.")
# TODO: Fix stats_file logic.
# self._setup_statsfile = self.savedir is not None
self._setup_statsfile = False
self._stats_file = None
self._stats_logger = None
self._observation_keys = list(observation_keys)
# Observations we always need.
for key in (
"glyphs",
"blstats",
"message",
"program_state",
"internal",
):
if key not in self._observation_keys:
self._observation_keys.append(key)
self._glyph_index = self._observation_keys.index("glyphs")
self._blstats_index = self._observation_keys.index("blstats")
self._message_index = self._observation_keys.index("message")
self._program_state_index = self._observation_keys.index(
"program_state")
self._internal_index = self._observation_keys.index("internal")
self._original_observation_keys = observation_keys
self._original_indices = tuple(
self._observation_keys.index(key) for key in observation_keys)
if self.savedir:
self._ttyrec_pattern = os.path.join(
self.savedir, "nle.%i.%%i.ttyrec.bz2" % os.getpid())
ttyrec = self._ttyrec_pattern % 0
else:
ttyrec = "/dev/null"
self.env = nethack.Nethack(
observation_keys=self._observation_keys,
options=options,
playername="Agent-" + self.character,
ttyrec=ttyrec,
wizard=wizard,
)
self._close_env = weakref.finalize(self, lambda e: e.close(), self.env)
self._random = random.SystemRandom()
# -1 so that it's 0-based on first reset
self._episode = -1
space_dict = {
"glyphs":
gym.spaces.Box(low=0,
high=nethack.MAX_GLYPH,
**nethack.OBSERVATION_DESC["glyphs"]),
"chars":
gym.spaces.Box(low=0,
high=255,
**nethack.OBSERVATION_DESC["chars"]),
"colors":
gym.spaces.Box(low=0,
high=15,
**nethack.OBSERVATION_DESC["colors"]),
"specials":
gym.spaces.Box(low=0,
high=255,
**nethack.OBSERVATION_DESC["specials"]),
"blstats":
gym.spaces.Box(
low=np.iinfo(np.int32).min,
high=np.iinfo(np.int32).max,
**nethack.OBSERVATION_DESC["blstats"],
),
"message":
gym.spaces.Box(
low=np.iinfo(np.uint8).min,
high=np.iinfo(np.uint8).max,
**nethack.OBSERVATION_DESC["message"],
),
"program_state":
gym.spaces.Box(
low=np.iinfo(np.int32).min,
high=np.iinfo(np.int32).max,
**nethack.OBSERVATION_DESC["program_state"],
),
"internal":
gym.spaces.Box(
low=np.iinfo(np.int32).min,
high=np.iinfo(np.int32).max,
**nethack.OBSERVATION_DESC["internal"],
),
"inv_glyphs":
gym.spaces.Box(
low=0,
high=nethack.MAX_GLYPH,
**nethack.OBSERVATION_DESC["inv_glyphs"],
),
"inv_strs":
gym.spaces.Box(low=0,
high=127,
**nethack.OBSERVATION_DESC["inv_strs"]),
"inv_letters":
gym.spaces.Box(low=0,
high=127,
**nethack.OBSERVATION_DESC["inv_letters"]),
"inv_oclasses":
gym.spaces.Box(
low=0,
high=nethack.MAXOCLASSES,
**nethack.OBSERVATION_DESC["inv_oclasses"],
),
"screen_descriptions":
gym.spaces.Box(low=0,
high=127,
**nethack.OBSERVATION_DESC["screen_descriptions"]),
}
self.observation_space = gym.spaces.Dict(
{key: space_dict[key]
for key in observation_keys})
self.action_space = gym.spaces.Discrete(len(self._actions))
def __init__(self, suffix=None, prefix=None, dir=None):
self.name = mkdtemp(suffix, prefix, dir)
self._finalizer = _weakref.finalize(
self, self._cleanup, self.name,
warn_message="Implicitly cleaning up {!r}".format(self))
[["--" + k.replace("_", "-"), convert_value(v)] for k, v in d.items()], []
)
def is_valid_xml(text):
return xml.etree.ElementTree.fromstring(text) is not None
try:
_offload_executor = ThreadPoolExecutor(
max_workers=1, thread_name_prefix="Dask-Offload"
)
except TypeError:
_offload_executor = ThreadPoolExecutor(max_workers=1)
weakref.finalize(_offload_executor, _offload_executor.shutdown)
def import_term(name: str):
""" Return the fully qualified term
Examples
--------
>>> import_term("math.sin")
<function math.sin(x, /)>
"""
try:
module_name, attr_name = name.rsplit(".", 1)
except ValueError:
return importlib.import_module(name)
def __new__(cls):
cls.n_instances += 1
obj = object.__new__(cls)
weakref.finalize(obj, cls._finalize)
return obj
from typing import Callable, Dict, List, Any, Optional
import config
from training_loop import TrainingLoop
from util import download
logger = logging.getLogger("bgsplit")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
# For caching dataset images
data_cache_dir = tempfile.TemporaryDirectory()
data_finalizer = weakref.finalize(
data_cache_dir, shutil.rmtree, data_cache_dir.name)
# Step 3: Call webhook to indicate completion
@backoff.on_exception(backoff.expo, requests.exceptions.RequestException)
def notify(url: str, payload: Dict[str, Any]):
r = requests.put(url, data=json.dumps(payload))
r.raise_for_status()
@dataclass
class TrainingJob:
train_positive_paths: List[str]
train_negative_paths: List[str]
train_unlabeled_paths: List[str]
val_positive_paths: List[str]
def __init__(self, basis, terms):
self._payload = _create_operator(basis, terms)
self._finalizer = weakref.finalize(self,
_destroy(_lib.ls_destroy_operator),
self._payload)
self.basis = basis
def __init__(
self,
save_ttyrec_every=0,
savedir=None,
character="mon-hum-neu-mal",
max_episode_steps=5000,
observation_keys=(
"glyphs",
"chars",
"colors",
"specials",
"blstats",
"message",
"inv_glyphs",
"inv_strs",
"inv_letters",
"inv_oclasses",
"screen_descriptions",
"tty_chars",
"tty_colors",
"tty_cursor",
),
actions=None,
options=None,
wizard=False,
allow_all_yn_questions=False,
allow_all_modes=False,
spawn_monsters=True,
):
"""Constructs a new NLE environment.
Args:
save_ttyrec_every: Integer, if 0, no ttyrecs (game recordings) will
be saved. Otherwise, save a ttyrec every Nth episode.
savedir (str or None): Path to save ttyrecs (game recordings) into,
if save_ttyrec_every is nonzero. If nonempty string, interpreted
as a path to a new or existing directory.
If "" (empty string) or None, NLE choses a unique directory name.
character (str): name of character. Defaults to "mon-hum-neu-mal".
max_episode_steps (int): maximum amount of steps allowed before the
game is forcefully quit. In such cases, ``info["end_status"]``
will be equal to ``StepStatus.ABORTED``. Defaults to 5000.
observation_keys (list): keys to use when creating the observation.
Defaults to all.
actions (list): list of actions. If None, the full action space will
be used, i.e. ``nle.nethack.ACTIONS``. Defaults to None.
options (list): list of game options to initialize Nethack. If None,
Nethack will be initialized with the options found in
``nle.nethack.NETHACKOPTIONS`. Defaults to None.
wizard (bool): activate wizard mode. Defaults to False.
allow_all_yn_questions (bool):
If set to True, no y/n questions in step() are declined.
If set to False, only elements of SKIP_EXCEPTIONS are not declined.
Defaults to False.
allow_all_modes (bool):
If set to True, do not decline menus, text input or auto 'MORE'.
If set to False, only skip click through 'MORE' on death.
spawn_monsters: If False, disables normal NetHack behavior to randomly
create monsters.
"""
self.character = character
self._max_episode_steps = max_episode_steps
self._allow_all_yn_questions = allow_all_yn_questions
self._allow_all_modes = allow_all_modes
self._save_ttyrec_every = save_ttyrec_every
if actions is None:
actions = FULL_ACTIONS
self.actions = actions
self.last_observation = ()
try:
if not save_ttyrec_every:
self.savedir = None
elif savedir:
self.savedir = os.path.abspath(savedir)
os.makedirs(self.savedir)
else: # Empty savedir: We create our unique savedir inside nle_data/.
parent_dir = os.path.join(os.getcwd(), "nle_data")
os.makedirs(parent_dir, exist_ok=True)
self.savedir = tempfile.mkdtemp(
prefix=time.strftime("%Y%m%d-%H%M%S_"), dir=parent_dir)
except FileExistsError:
logger.info("Using existing savedir: %s", self.savedir)
else:
if self.savedir:
logger.info("Created savedir: %s", self.savedir)
else:
logger.info("Not saving any NLE data.")
self._observation_keys = list(observation_keys)
if "internal" in self._observation_keys:
logger.warn(
"The 'internal' NLE observation was requested. "
"This might contain data that shouldn't be available to agents."
)
# Observations we always need.
for key in (
"glyphs",
"blstats",
"message",
"program_state",
"internal",
):
if key not in self._observation_keys:
self._observation_keys.append(key)
self._glyph_index = self._observation_keys.index("glyphs")
self._blstats_index = self._observation_keys.index("blstats")
self._message_index = self._observation_keys.index("message")
self._program_state_index = self._observation_keys.index(
"program_state")
self._internal_index = self._observation_keys.index("internal")
self._original_observation_keys = observation_keys
self._original_indices = tuple(
self._observation_keys.index(key) for key in observation_keys)
if self.savedir:
self._ttyrec_pattern = os.path.join(
self.savedir, "nle.%i.%%i.ttyrec.bz2" % os.getpid())
ttyrec = self._ttyrec_pattern % 0
else:
ttyrec = None
self.nethack = nethack.Nethack(
observation_keys=self._observation_keys,
options=options,
playername="Agent-" + self.character,
ttyrec=ttyrec,
wizard=wizard,
spawn_monsters=spawn_monsters,
)
self._close_nethack = weakref.finalize(self, self.nethack.close)
self._random = random.SystemRandom()
# -1 so that it's 0-based on first reset
self._episode = -1
space_dict = dict(NLE_SPACE_ITEMS)
self.observation_space = gym.spaces.Dict(
{key: space_dict[key]
for key in observation_keys})
self.action_space = gym.spaces.Discrete(len(self.actions))
people = [1, 2, 3]
bus1 = Bus(people)
bus2 = Bus(people)
bus2.pick(4)
print(bus1.passengers, bus2.passengers)
import weakref
def bye():
print('bye~')
s1 = {1, 2, 3}
s2 = s1
f = weakref.finalize(s1, bye)
del s1
print(f.alive)
# del s2
s2 = {1}
print(f.alive)
import weakref
s = {1, 2, 3}
wref = weakref.ref(s)
print(wref())
s = {1, 2}
print(wref())
# input()
print(wref())
def __init__(self,
ctx: 'Context',
size: Tuple[int, int],
*,
components: int = 4,
dtype: str = 'f1',
data: Any = None,
filter: Tuple[gl.GLuint, gl.GLuint] = None,
wrap_x: gl.GLuint = None,
wrap_y: gl.GLuint = None):
"""
A texture can be created with or without initial data.
NOTE: Currently does not support multisample textures even
thought ``samples`` is exposed.
:param Context ctx: The context the object belongs to
:param Tuple[int, int] size: The size of the texture
:param int components: The number of components (1: R, 2: RG, 3: RGB, 4: RGBA)
:param str dtype: The data type of each component: f1, f2, f4 / i1, i2, i4 / u1, u2, u4
:param Any data: The byte data of the texture. bytes or anything supporting the buffer protocol.
:param Tuple[gl.GLuint, gl.GLuint] filter: The minification/magnification filter of the texture
:param gl.GLuint wrap_s
:param data: The texture data (optional)
"""
self._ctx = ctx
self._width, self._height = size
self._dtype = dtype
self._components = components
self._target = gl.GL_TEXTURE_2D
self._samples = 0
# Default filters for float and integer textures
if 'f' in self.dtype:
self._filter = gl.GL_LINEAR, gl.GL_LINEAR
else:
self._filter = gl.GL_NEAREST, gl.GL_NEAREST
self._wrap_x = gl.GL_REPEAT
self._wrap_y = gl.GL_REPEAT
if components not in [1, 2, 3, 4]:
raise ValueError("Components must be 1, 2, 3 or 4")
try:
format_info = self._formats[self._dtype]
except KeyError:
raise ValueError(
f"dype '{dtype}' not support. Supported types are : {tuple(self._formats.keys())}"
)
gl.glActiveTexture(
gl.GL_TEXTURE0) # Create textures in the default channel (0)
self._glo = glo = gl.GLuint()
gl.glGenTextures(1, byref(self._glo))
if self._glo.value == 0:
raise RuntimeError(
"Cannot create Texture. OpenGL failed to generate a texture id"
)
gl.glBindTexture(self._target, self._glo)
gl.glPixelStorei(gl.GL_PACK_ALIGNMENT, 1)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
if data is not None:
byte_length, data = data_to_ctypes(data)
try:
_format, _internal_format, self._type, self._component_size = format_info
self._format = _format[components]
self._internal_format = _internal_format[components]
gl.glTexImage2D(
self._target, # target
0, # level
self._internal_format, # internal_format
self._width, # width
self._height, # height
0, # border
self._format, # format
self._type, # type
data # data
)
except gl.GLException as ex:
raise gl.GLException((
f"Unable to create texture: {ex} : dtype={dtype} size={size} components={components} "
"MAX_TEXTURE_SIZE = {self.ctx.limits.MAX_TEXTURE_SIZE}"))
self.filter = filter or self._filter
self.wrap_x = wrap_x or self._wrap_x
self.wrap_y = wrap_y or self._wrap_y
self.ctx.stats.incr('texture')
weakref.finalize(self, Texture.release, self._ctx, glo)
def on_destroy(instance, function, *args, **kwargs):
weakref.finalize(instance, function, *args, **kwargs)
async def _start(self):
self._generate_name = self._generate_name or dask.config.get(
"kubernetes.name")
self._namespace = self._namespace or dask.config.get(
"kubernetes.namespace")
self._idle_timeout = self._idle_timeout or dask.config.get(
"kubernetes.idle-timeout")
self._scheduler_service_wait_timeout = (
self._scheduler_service_wait_timeout
or dask.config.get("kubernetes.scheduler-service-wait-timeout"))
self._deploy_mode = self._deploy_mode or dask.config.get(
"kubernetes.deploy-mode")
self._n_workers = (self._n_workers if self._n_workers is not None else
dask.config.get("kubernetes.count.start"))
self.host = self.host or dask.config.get("kubernetes.host")
self.port = (self.port if self.port is not None else
dask.config.get("kubernetes.port"))
self._protocol = self._protocol or dask.config.get(
"kubernetes.protocol")
self._interface = self._interface or dask.config.get(
"kubernetes.interface")
self._dashboard_address = self._dashboard_address or dask.config.get(
"kubernetes.dashboard_address")
self.env = (self.env if self.env is not None else
dask.config.get("kubernetes.env"))
self.pod_template = self._get_pod_template(self.pod_template,
pod_type="worker")
self.scheduler_pod_template = self._get_pod_template(
self.scheduler_pod_template, pod_type="scheduler")
if not self.pod_template:
msg = ("Worker pod specification not provided. See KubeCluster "
"docstring for ways to specify workers")
raise ValueError(msg)
base_pod_template = self.pod_template
self.pod_template = clean_pod_template(self.pod_template,
pod_type="worker")
if not self.scheduler_pod_template:
self.scheduler_pod_template = base_pod_template
self.scheduler_pod_template.spec.containers[0].args = [
"dask-scheduler"
]
self.scheduler_pod_template = clean_pod_template(
self.scheduler_pod_template, pod_type="scheduler")
await ClusterAuth.load_first(self.auth)
self.core_api = kubernetes.client.CoreV1Api()
if self._namespace is None:
self._namespace = _namespace_default()
self._generate_name = self._generate_name.format(
user=getpass.getuser(), uuid=str(uuid.uuid4())[:10], **os.environ)
self._generate_name = escape(self._generate_name)
self.pod_template = self._fill_pod_templates(self.pod_template,
pod_type="worker")
self.scheduler_pod_template = self._fill_pod_templates(
self.scheduler_pod_template, pod_type="scheduler")
finalize(self, _cleanup_resources, self._namespace,
self.pod_template.metadata.labels)
common_options = {
"core_api": self.core_api,
"namespace": self._namespace,
"loop": self.loop,
}
if self._deploy_mode == "local":
self.scheduler_spec = {
"cls": dask.distributed.Scheduler,
"options": {
"protocol": self._protocol,
"interface": self._interface,
"host": self.host,
"port": self.port,
"dashboard_address": self._dashboard_address,
"security": self.security,
},
}
elif self._deploy_mode == "remote":
self.scheduler_spec = {
"cls": Scheduler,
"options": {
"idle_timeout": self._idle_timeout,
"service_wait_timeout_s":
self._scheduler_service_wait_timeout,
"pod_template": self.scheduler_pod_template,
**common_options,
},
}
else:
raise RuntimeError("Unknown deploy mode %s" % self._deploy_mode)
self.new_spec = {
"cls": Worker,
"options": {
"pod_template": self.pod_template,
**common_options
},
}
self.worker_spec = {i: self.new_spec for i in range(self._n_workers)}
await super()._start()
import weakref
class ExpensiveObj:
def __del__(self):
print('Deleting {}'.format(self))
def on_finalize(*args):
print('on_finalize({!r})'.format(args))
obj = ExpensiveObj()
weakref.finalize(obj, on_finalize, 'extra argument')
del obj
