6biSrSSKrSSKrSSKJr 0r0r\R"5r\"SSS5"SS55r \"S S 5S 5r \"S S 5SSj5r \"SS5S5r \"SS5SSj5r \ rg)z&Python utilities required by TF-Keras.N) keras_exportz keras.saving.custom_object_scopezkeras.utils.custom_object_scopezkeras.utils.CustomObjectScopec*\rSrSrSrSrSrSrSrg)CustomObjectScopeaExposes custom classes/functions to TF-Keras deserialization internals. Under a scope `with custom_object_scope(objects_dict)`, TF-Keras methods such as `tf.keras.models.load_model` or `tf.keras.models.model_from_config` will be able to deserialize any custom object referenced by a saved config (e.g. a custom layer or metric). Example: Consider a custom regularizer `my_regularizer`: ```python layer = Dense(3, kernel_regularizer=my_regularizer) # Config contains a reference to `my_regularizer` config = layer.get_config() ... # Later: with custom_object_scope({'my_regularizer': my_regularizer}): layer = Dense.from_config(config) ``` Args: *args: Dictionary or dictionaries of `{name: object}` pairs. cXlSUlgN)custom_objectsbackup)selfargss a/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/saving/object_registration.py__init__CustomObjectScope.__init__<s" c[RR5UlURH"n[RR U5 M$ U$r)_THREAD_LOCAL_CUSTOM_OBJECTS__dict__copyr r update)r objectss r __enter__CustomObjectScope.__enter__@sA2;;@@B **G ( 1 1 8 8 A+ rc[RR5 [RRUR5 gr)rrclearrr )r r kwargss r __exit__CustomObjectScope.__exit__Fs,$--335$--44T[[Ar)r r N) __name__ __module__ __qualname____firstlineno____doc__rrr__static_attributes__rr rrs 2 Brrzkeras.saving.get_custom_objectszkeras.utils.get_custom_objectsc[$)aRetrieves a live reference to the global dictionary of custom objects. Custom objects set using using `custom_object_scope` are not added to the global dictionary of custom objects, and will not appear in the returned dictionary. Example: ```python get_custom_objects().clear() get_custom_objects()['MyObject'] = MyObject ``` Returns: Global dictionary mapping registered class names to classes. )_GLOBAL_CUSTOM_OBJECTSr$rr get_custom_objectsr'Ks ( "!rz(keras.saving.register_keras_serializablez'keras.utils.register_keras_serializablec^^UU4SjnU$)a*Registers an object with the TF-Keras serialization framework. This decorator injects the decorated class or function into the TF-Keras custom object dictionary, so that it can be serialized and deserialized without needing an entry in the user-provided custom object dict. It also injects a function that TF-Keras will call to get the object's serializable string key. Note that to be serialized and deserialized, classes must implement the `get_config()` method. Functions do not have this requirement. The object will be registered under the key 'package>name' where `name`, defaults to the object name if not passed. Example: ```python # Note that `'my_package'` is used as the `package` argument here, and since # the `name` argument is not provided, `'MyDense'` is used as the `name`. @keras.saving.register_keras_serializable('my_package') class MyDense(keras.layers.Dense): pass assert keras.saving.get_registered_object('my_package>MyDense') == MyDense assert keras.saving.get_registered_name(MyDense) == 'my_package>MyDense' ``` Args: package: The package that this class belongs to. This is used for the `key` (which is `"package>name"`) to idenfify the class. Note that this is the first argument passed into the decorator. name: The name to serialize this class under in this package. If not provided or `None`, the class' name will be used (note that this is the case when the decorator is used with only one argument, which becomes the `package`). Returns: A decorator that registers the decorated class with the passed names. c>TbTO URnTS-U-n[R"U5(a[US5(d [ S5eU[ U'U[ U'U$)z get_configzACannot register a class that does not have a get_config() method.)rinspectisclasshasattr ValueErrorr&_GLOBAL_CUSTOM_NAMES)arg class_nameregistered_namenamepackages r decorator.register_keras_serializable..decoratorsk!-T3<< !C-*4 ??3  \(B(B'  36/$3S! rr$)r5r4r6s`` r register_keras_serializabler8bsZ rz keras.saving.get_registered_namezkeras.utils.get_registered_namec@U[;a [U$UR$)aReturns the name registered to an object within the TF-Keras framework. This function is part of the TF-Keras serialization and deserialization framework. It maps objects to the string names associated with those objects for serialization/deserialization. Args: obj: The object to look up. Returns: The name associated with the object, or the default Python name if the object is not registered. )r0r)objs r get_registered_namer;s"" ""#C((||rz"keras.saving.get_registered_objectz!keras.utils.get_registered_objectcU[R;a[RU$U[;a [U$U(a X;aX$U(a X;aX $g)aReturns the class associated with `name` if it is registered with TF-Keras. This function is part of the TF-Keras serialization and deserialization framework. It maps strings to the objects associated with them for serialization/deserialization. Example: ```python def from_config(cls, config, custom_objects=None): if 'my_custom_object_name' in config: config['hidden_cls'] = tf.keras.saving.get_registered_object( config['my_custom_object_name'], custom_objects=custom_objects) ``` Args: name: The name to look up. custom_objects: A dictionary of custom objects to look the name up in. Generally, custom_objects is provided by the user. module_objects: A dictionary of custom objects to look the name up in. Generally, module_objects is provided by midlevel library implementers. Returns: An instantiable class associated with `name`, or `None` if no such class exists. N)rrr&)r4r module_objectss r get_registered_objectr>s]> +444+44T:: ' '%d++ D2## D2## r)CustomN)NN)r"r, threading tensorflow.python.util.tf_exportrr&r0localrrr'r8r;r>custom_object_scoper$rr rDs-:(0&%# &B&B  &BR%'G""(.-9 9x&(I((*M$$P(r