[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=d12c73c0eef36df8]*/
-// Imports
-static PyObject *io_open = NULL;
-static PyObject *_tzpath_find_tzfile = NULL;
-static PyObject *_common_mod = NULL;
typedef struct TransitionRuleType TransitionRuleType;
typedef struct StrongCacheNode StrongCacheNode;
PyObject *zone;
};
-static PyTypeObject PyZoneInfo_ZoneInfoType;
+typedef struct {
+ PyTypeObject *ZoneInfoType;
+
+ // Imports
+ PyObject *io_open;
+ PyObject *_tzpath_find_tzfile;
+ PyObject *_common_mod;
-// Globals
-static PyObject *TIMEDELTA_CACHE = NULL;
-static PyObject *ZONEINFO_WEAK_CACHE = NULL;
-static StrongCacheNode *ZONEINFO_STRONG_CACHE = NULL;
-static size_t ZONEINFO_STRONG_CACHE_MAX_SIZE = 8;
+ // Caches
+ PyObject *TIMEDELTA_CACHE;
+ PyObject *ZONEINFO_WEAK_CACHE;
+ StrongCacheNode *ZONEINFO_STRONG_CACHE;
-static _ttinfo NO_TTINFO = {NULL, NULL, NULL, 0};
+ _ttinfo NO_TTINFO;
+} zoneinfo_state;
// Constants
static const int EPOCHORDINAL = 719163;
static const int SOURCE_CACHE = 1;
static const int SOURCE_FILE = 2;
+static const size_t ZONEINFO_STRONG_CACHE_MAX_SIZE = 8;
+
// Forward declarations
static int
-load_data(PyZoneInfo_ZoneInfo *self, PyObject *file_obj);
+load_data(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self,
+ PyObject *file_obj);
static void
utcoff_to_dstoff(size_t *trans_idx, long *utcoffs, long *dstoffs,
unsigned char *isdsts, size_t num_transitions,
size_t num_transitions);
static int
-parse_tz_str(PyObject *tz_str_obj, _tzrule *out);
+parse_tz_str(zoneinfo_state *state, PyObject *tz_str_obj, _tzrule *out);
static Py_ssize_t
parse_abbr(const char *const p, PyObject **abbr);
unsigned char *fold);
static int
-build_ttinfo(long utcoffset, long dstoffset, PyObject *tzname, _ttinfo *out);
+build_ttinfo(zoneinfo_state *state, long utcoffset, long dstoffset,
+ PyObject *tzname, _ttinfo *out);
static void
xdecref_ttinfo(_ttinfo *ttinfo);
static int
ttinfo_eq(const _ttinfo *const tti0, const _ttinfo *const tti1);
static int
-build_tzrule(PyObject *std_abbr, PyObject *dst_abbr, long std_offset,
- long dst_offset, TransitionRuleType *start,
+build_tzrule(zoneinfo_state *state, PyObject *std_abbr, PyObject *dst_abbr,
+ long std_offset, long dst_offset, TransitionRuleType *start,
TransitionRuleType *end, _tzrule *out);
static void
free_tzrule(_tzrule *tzrule);
static PyObject *
-load_timedelta(long seconds);
+load_timedelta(zoneinfo_state *state, long seconds);
static int
get_local_timestamp(PyObject *dt, int64_t *local_ts);
static _ttinfo *
-find_ttinfo(PyZoneInfo_ZoneInfo *self, PyObject *dt);
+find_ttinfo(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *dt);
static int
ymd_to_ord(int y, int m, int d);
_bisect(const int64_t value, const int64_t *arr, size_t size);
static int
-eject_from_strong_cache(const PyTypeObject *const type, PyObject *key);
+eject_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *key);
static void
-clear_strong_cache(const PyTypeObject *const type);
+clear_strong_cache(zoneinfo_state *state, const PyTypeObject *const type);
static void
-update_strong_cache(const PyTypeObject *const type, PyObject *key,
- PyObject *zone);
+update_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *key, PyObject *zone);
static PyObject *
-zone_from_strong_cache(const PyTypeObject *const type, PyObject *const key);
+zone_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *const key);
+
+static inline zoneinfo_state *
+zoneinfo_get_state(PyObject *mod)
+{
+ zoneinfo_state *state = (zoneinfo_state *)PyModule_GetState(mod);
+ assert(state != NULL);
+ return state;
+}
+
+static inline zoneinfo_state *
+zoneinfo_get_state_by_cls(PyTypeObject *cls)
+{
+ zoneinfo_state *state = (zoneinfo_state *)PyType_GetModuleState(cls);
+ assert(state != NULL);
+ return state;
+}
+
+static struct PyModuleDef zoneinfomodule;
+
+static inline zoneinfo_state *
+zoneinfo_get_state_by_self(PyTypeObject *self)
+{
+ PyObject *mod = PyType_GetModuleByDef(self, &zoneinfomodule);
+ assert(mod != NULL);
+ return zoneinfo_get_state(mod);
+}
static PyObject *
-zoneinfo_new_instance(PyTypeObject *type, PyObject *key)
+zoneinfo_new_instance(zoneinfo_state *state, PyTypeObject *type, PyObject *key)
{
PyObject *file_obj = NULL;
PyObject *file_path = NULL;
- file_path = PyObject_CallFunctionObjArgs(_tzpath_find_tzfile, key, NULL);
+ file_path = PyObject_CallFunctionObjArgs(state->_tzpath_find_tzfile,
+ key, NULL);
if (file_path == NULL) {
return NULL;
}
else if (file_path == Py_None) {
- file_obj = PyObject_CallMethod(_common_mod, "load_tzdata", "O", key);
+ PyObject *meth = state->_common_mod;
+ file_obj = PyObject_CallMethod(meth, "load_tzdata", "O", key);
if (file_obj == NULL) {
Py_DECREF(file_path);
return NULL;
}
if (file_obj == NULL) {
- file_obj = PyObject_CallFunction(io_open, "Os", file_path, "rb");
+ PyObject *func = state->io_open;
+ file_obj = PyObject_CallFunction(func, "Os", file_path, "rb");
if (file_obj == NULL) {
goto error;
}
}
- if (load_data((PyZoneInfo_ZoneInfo *)self, file_obj)) {
+ if (load_data(state, (PyZoneInfo_ZoneInfo *)self, file_obj)) {
goto error;
}
}
static PyObject *
-get_weak_cache(PyTypeObject *type)
+get_weak_cache(zoneinfo_state *state, PyTypeObject *type)
{
- if (type == &PyZoneInfo_ZoneInfoType) {
- return ZONEINFO_WEAK_CACHE;
+ if (type == state->ZoneInfoType) {
+ return state->ZONEINFO_WEAK_CACHE;
}
else {
PyObject *cache =
return NULL;
}
- PyObject *instance = zone_from_strong_cache(type, key);
+ zoneinfo_state *state = zoneinfo_get_state_by_self(type);
+ PyObject *instance = zone_from_strong_cache(state, type, key);
if (instance != NULL || PyErr_Occurred()) {
return instance;
}
- PyObject *weak_cache = get_weak_cache(type);
+ PyObject *weak_cache = get_weak_cache(state, type);
instance = PyObject_CallMethod(weak_cache, "get", "O", key, Py_None);
if (instance == NULL) {
return NULL;
if (instance == Py_None) {
Py_DECREF(instance);
- PyObject *tmp = zoneinfo_new_instance(type, key);
+ PyObject *tmp = zoneinfo_new_instance(state, type, key);
if (tmp == NULL) {
return NULL;
}
((PyZoneInfo_ZoneInfo *)instance)->source = SOURCE_CACHE;
}
- update_strong_cache(type, key, instance);
+ update_strong_cache(state, type, key, instance);
return instance;
}
+static int
+zoneinfo_traverse(PyZoneInfo_ZoneInfo *self, visitproc visit, void *arg)
+{
+ Py_VISIT(Py_TYPE(self));
+ Py_VISIT(self->key);
+ return 0;
+}
+
+static int
+zoneinfo_clear(PyZoneInfo_ZoneInfo *self)
+{
+ Py_CLEAR(self->key);
+ Py_CLEAR(self->file_repr);
+ return 0;
+}
+
static void
zoneinfo_dealloc(PyObject *obj_self)
{
PyZoneInfo_ZoneInfo *self = (PyZoneInfo_ZoneInfo *)obj_self;
+ PyTypeObject *tp = Py_TYPE(self);
+ PyObject_GC_UnTrack(self);
if (self->weakreflist != NULL) {
PyObject_ClearWeakRefs(obj_self);
free_tzrule(&(self->tzrule_after));
- Py_XDECREF(self->key);
- Py_XDECREF(self->file_repr);
-
- Py_TYPE(self)->tp_free((PyObject *)self);
+ zoneinfo_clear(self);
+ tp->tp_free(obj_self);
+ Py_DECREF(tp);
}
/*[clinic input]
@classmethod
zoneinfo.ZoneInfo.from_file
+ cls: defining_class
file_obj: object
/
key: object = None
[clinic start generated code]*/
static PyObject *
-zoneinfo_ZoneInfo_from_file_impl(PyTypeObject *type, PyObject *file_obj,
- PyObject *key)
-/*[clinic end generated code: output=68ed2022404ae5be input=ccfe73708133d2e4]*/
+zoneinfo_ZoneInfo_from_file_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *file_obj, PyObject *key)
+/*[clinic end generated code: output=77887d1d56a48324 input=d26111f29eed6863]*/
{
PyObject *file_repr = NULL;
PyZoneInfo_ZoneInfo *self = NULL;
goto error;
}
- if (load_data(self, file_obj)) {
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ if (load_data(state, self, file_obj)) {
goto error;
}
@classmethod
zoneinfo.ZoneInfo.no_cache
+ cls: defining_class
+ /
key: object
Get a new instance of ZoneInfo, bypassing the cache.
[clinic start generated code]*/
static PyObject *
-zoneinfo_ZoneInfo_no_cache_impl(PyTypeObject *type, PyObject *key)
-/*[clinic end generated code: output=751c6894ad66f91b input=bb24afd84a80ba46]*/
+zoneinfo_ZoneInfo_no_cache_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *key)
+/*[clinic end generated code: output=b0b09b3344c171b7 input=0238f3d56b1ea3f1]*/
{
- PyObject *out = zoneinfo_new_instance(type, key);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ PyObject *out = zoneinfo_new_instance(state, type, key);
if (out != NULL) {
((PyZoneInfo_ZoneInfo *)out)->source = SOURCE_NOCACHE;
}
@classmethod
zoneinfo.ZoneInfo.clear_cache
+ cls: defining_class
+ /
*
only_keys: object = None
[clinic start generated code]*/
static PyObject *
-zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyObject *only_keys)
-/*[clinic end generated code: output=eec0a3276f07bd90 input=8cff0182a95f295b]*/
+zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *only_keys)
+/*[clinic end generated code: output=114d9b7c8a22e660 input=e32ca3bb396788ba]*/
{
- PyObject *weak_cache = get_weak_cache(type);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ PyObject *weak_cache = get_weak_cache(state, type);
if (only_keys == NULL || only_keys == Py_None) {
PyObject *rv = PyObject_CallMethod(weak_cache, "clear", NULL);
Py_DECREF(rv);
}
- clear_strong_cache(type);
+ clear_strong_cache(state, type);
}
else {
PyObject *item = NULL;
while ((item = PyIter_Next(iter))) {
// Remove from strong cache
- if (eject_from_strong_cache(type, item) < 0) {
+ if (eject_from_strong_cache(state, type, item) < 0) {
Py_DECREF(item);
break;
}
Py_RETURN_NONE;
}
+/*[clinic input]
+zoneinfo.ZoneInfo.utcoffset
+
+ cls: defining_class
+ dt: object
+ /
+
+Retrieve a timedelta representing the UTC offset in a zone at the given datetime.
+[clinic start generated code]*/
+
static PyObject *
-zoneinfo_utcoffset(PyObject *self, PyObject *dt)
+zoneinfo_ZoneInfo_utcoffset_impl(PyObject *self, PyTypeObject *cls,
+ PyObject *dt)
+/*[clinic end generated code: output=b71016c319ba1f91 input=2bb6c5364938f19c]*/
{
- _ttinfo *tti = find_ttinfo((PyZoneInfo_ZoneInfo *)self, dt);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ _ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);
if (tti == NULL) {
return NULL;
}
return Py_NewRef(tti->utcoff);
}
+/*[clinic input]
+zoneinfo.ZoneInfo.dst
+
+ cls: defining_class
+ dt: object
+ /
+
+Retrieve a timedelta representing the amount of DST applied in a zone at the given datetime.
+[clinic start generated code]*/
+
static PyObject *
-zoneinfo_dst(PyObject *self, PyObject *dt)
+zoneinfo_ZoneInfo_dst_impl(PyObject *self, PyTypeObject *cls, PyObject *dt)
+/*[clinic end generated code: output=cb6168d7723a6ae6 input=2167fb80cf8645c6]*/
{
- _ttinfo *tti = find_ttinfo((PyZoneInfo_ZoneInfo *)self, dt);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ _ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);
if (tti == NULL) {
return NULL;
}
return Py_NewRef(tti->dstoff);
}
+/*[clinic input]
+zoneinfo.ZoneInfo.tzname
+
+ cls: defining_class
+ dt: object
+ /
+
+Retrieve a string containing the abbreviation for the time zone that applies in a zone at a given datetime.
+[clinic start generated code]*/
+
static PyObject *
-zoneinfo_tzname(PyObject *self, PyObject *dt)
+zoneinfo_ZoneInfo_tzname_impl(PyObject *self, PyTypeObject *cls,
+ PyObject *dt)
+/*[clinic end generated code: output=3b6ae6c3053ea75a input=15a59a4f92ed1f1f]*/
{
- _ttinfo *tti = find_ttinfo((PyZoneInfo_ZoneInfo *)self, dt);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ _ttinfo *tti = find_ttinfo(state, (PyZoneInfo_ZoneInfo *)self, dt);
if (tti == NULL) {
return NULL;
}
return rv;
}
+/*[clinic input]
+@classmethod
+zoneinfo.ZoneInfo._unpickle
+
+ cls: defining_class
+ key: object
+ from_cache: unsigned_char(bitwise=True)
+ /
+
+Private method used in unpickling.
+[clinic start generated code]*/
+
static PyObject *
-zoneinfo__unpickle(PyTypeObject *cls, PyObject *args)
+zoneinfo_ZoneInfo__unpickle_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *key, unsigned char from_cache)
+/*[clinic end generated code: output=556712fc709deecb input=6ac8c73eed3de316]*/
{
- PyObject *key;
- unsigned char from_cache;
- if (!PyArg_ParseTuple(args, "OB", &key, &from_cache)) {
- return NULL;
- }
-
if (from_cache) {
PyObject *val_args = Py_BuildValue("(O)", key);
if (val_args == NULL) {
return NULL;
}
- PyObject *rv = zoneinfo_new(cls, val_args, NULL);
+ PyObject *rv = zoneinfo_new(type, val_args, NULL);
Py_DECREF(val_args);
return rv;
}
else {
- return zoneinfo_new_instance(cls, key);
+ zoneinfo_state *state = zoneinfo_get_state_by_cls(cls);
+ return zoneinfo_new_instance(state, type, key);
}
}
* This returns a new reference to the timedelta.
*/
static PyObject *
-load_timedelta(long seconds)
+load_timedelta(zoneinfo_state *state, long seconds)
{
PyObject *rv;
PyObject *pyoffset = PyLong_FromLong(seconds);
if (pyoffset == NULL) {
return NULL;
}
- rv = PyDict_GetItemWithError(TIMEDELTA_CACHE, pyoffset);
+ rv = PyDict_GetItemWithError(state->TIMEDELTA_CACHE, pyoffset);
if (rv == NULL) {
if (PyErr_Occurred()) {
goto error;
goto error;
}
- rv = PyDict_SetDefault(TIMEDELTA_CACHE, pyoffset, tmp);
+ rv = PyDict_SetDefault(state->TIMEDELTA_CACHE, pyoffset, tmp);
Py_DECREF(tmp);
}
* initialized _ttinfo objects.
*/
static int
-build_ttinfo(long utcoffset, long dstoffset, PyObject *tzname, _ttinfo *out)
+build_ttinfo(zoneinfo_state *state, long utcoffset, long dstoffset,
+ PyObject *tzname, _ttinfo *out)
{
out->utcoff = NULL;
out->dstoff = NULL;
out->tzname = NULL;
out->utcoff_seconds = utcoffset;
- out->utcoff = load_timedelta(utcoffset);
+ out->utcoff = load_timedelta(state, utcoffset);
if (out->utcoff == NULL) {
return -1;
}
- out->dstoff = load_timedelta(dstoffset);
+ out->dstoff = load_timedelta(state, dstoffset);
if (out->dstoff == NULL) {
return -1;
}
* the object only needs to be freed / deallocated if this succeeds.
*/
static int
-load_data(PyZoneInfo_ZoneInfo *self, PyObject *file_obj)
+load_data(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *file_obj)
{
PyObject *data_tuple = NULL;
size_t ttinfos_allocated = 0;
- data_tuple = PyObject_CallMethod(_common_mod, "load_data", "O", file_obj);
+ data_tuple = PyObject_CallMethod(state->_common_mod, "load_data", "O",
+ file_obj);
if (data_tuple == NULL) {
goto error;
}
ttinfos_allocated++;
- if (build_ttinfo(utcoff[i], dstoff[i], tzname, &(self->_ttinfos[i]))) {
+ int rc = build_ttinfo(state, utcoff[i], dstoff[i], tzname,
+ &(self->_ttinfos[i]));
+ if (rc) {
goto error;
}
}
}
if (tz_str != Py_None && PyObject_IsTrue(tz_str)) {
- if (parse_tz_str(tz_str, &(self->tzrule_after))) {
+ if (parse_tz_str(state, tz_str, &(self->tzrule_after))) {
goto error;
}
}
}
_ttinfo *tti = &(self->_ttinfos[idx]);
- build_tzrule(tti->tzname, NULL, tti->utcoff_seconds, 0, NULL, NULL,
- &(self->tzrule_after));
+ build_tzrule(state, tti->tzname, NULL, tti->utcoff_seconds, 0, NULL,
+ NULL, &(self->tzrule_after));
// We've abused the build_tzrule constructor to construct an STD-only
// rule mimicking whatever ttinfo we've picked up, but it's possible
* https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html
*/
static int
-parse_tz_str(PyObject *tz_str_obj, _tzrule *out)
+parse_tz_str(zoneinfo_state *state, PyObject *tz_str_obj, _tzrule *out)
{
PyObject *std_abbr = NULL;
PyObject *dst_abbr = NULL;
}
complete:
- build_tzrule(std_abbr, dst_abbr, std_offset, dst_offset, start, end, out);
+ build_tzrule(state, std_abbr, dst_abbr, std_offset, dst_offset,
+ start, end, out);
Py_DECREF(std_abbr);
Py_XDECREF(dst_abbr);
* Returns 0 on success.
*/
static int
-build_tzrule(PyObject *std_abbr, PyObject *dst_abbr, long std_offset,
- long dst_offset, TransitionRuleType *start,
+build_tzrule(zoneinfo_state *state, PyObject *std_abbr, PyObject *dst_abbr,
+ long std_offset, long dst_offset, TransitionRuleType *start,
TransitionRuleType *end, _tzrule *out)
{
_tzrule rv = {{0}};
rv.start = start;
rv.end = end;
- if (build_ttinfo(std_offset, 0, std_abbr, &rv.std)) {
+ if (build_ttinfo(state, std_offset, 0, std_abbr, &rv.std)) {
goto error;
}
if (dst_abbr != NULL) {
rv.dst_diff = dst_offset - std_offset;
- if (build_ttinfo(dst_offset, rv.dst_diff, dst_abbr, &rv.dst)) {
+ if (build_ttinfo(state, dst_offset, rv.dst_diff, dst_abbr, &rv.dst)) {
goto error;
}
}
/* Find the ttinfo rules that apply at a given local datetime. */
static _ttinfo *
-find_ttinfo(PyZoneInfo_ZoneInfo *self, PyObject *dt)
+find_ttinfo(zoneinfo_state *state, PyZoneInfo_ZoneInfo *self, PyObject *dt)
{
// datetime.time has a .tzinfo attribute that passes None as the dt
// argument; it only really has meaning for fixed-offset zones.
return &(self->tzrule_after.std);
}
else {
- return &NO_TTINFO;
+ return &(state->NO_TTINFO);
}
}
* the front of the cache.
*/
static void
-remove_from_strong_cache(StrongCacheNode *node)
+remove_from_strong_cache(zoneinfo_state *state, StrongCacheNode *node)
{
- if (ZONEINFO_STRONG_CACHE == node) {
- ZONEINFO_STRONG_CACHE = node->next;
+ if (state->ZONEINFO_STRONG_CACHE == node) {
+ state->ZONEINFO_STRONG_CACHE = node->next;
}
if (node->prev != NULL) {
* This function is used to enable the per-key functionality in clear_cache.
*/
static int
-eject_from_strong_cache(const PyTypeObject *const type, PyObject *key)
+eject_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *key)
{
- if (type != &PyZoneInfo_ZoneInfoType) {
+ if (type != state->ZoneInfoType) {
return 0;
}
- StrongCacheNode *node = find_in_strong_cache(ZONEINFO_STRONG_CACHE, key);
+ StrongCacheNode *cache = state->ZONEINFO_STRONG_CACHE;
+ StrongCacheNode *node = find_in_strong_cache(cache, key);
if (node != NULL) {
- remove_from_strong_cache(node);
+ remove_from_strong_cache(state, node);
strong_cache_node_free(node);
}
* it is not at the front of the cache, it needs to be moved there.
*/
static void
-move_strong_cache_node_to_front(StrongCacheNode **root, StrongCacheNode *node)
+move_strong_cache_node_to_front(zoneinfo_state *state, StrongCacheNode **root,
+ StrongCacheNode *node)
{
StrongCacheNode *root_p = *root;
if (root_p == node) {
return;
}
- remove_from_strong_cache(node);
+ remove_from_strong_cache(state, node);
node->prev = NULL;
node->next = root_p;
* always returns a cache miss for subclasses.
*/
static PyObject *
-zone_from_strong_cache(const PyTypeObject *const type, PyObject *const key)
+zone_from_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *const key)
{
- if (type != &PyZoneInfo_ZoneInfoType) {
+ if (type != state->ZoneInfoType) {
return NULL; // Strong cache currently only implemented for base class
}
- StrongCacheNode *node = find_in_strong_cache(ZONEINFO_STRONG_CACHE, key);
+ StrongCacheNode *cache = state->ZONEINFO_STRONG_CACHE;
+ StrongCacheNode *node = find_in_strong_cache(cache, key);
if (node != NULL) {
- move_strong_cache_node_to_front(&ZONEINFO_STRONG_CACHE, node);
+ StrongCacheNode **root = &(state->ZONEINFO_STRONG_CACHE);
+ move_strong_cache_node_to_front(state, root, node);
return Py_NewRef(node->zone);
}
* the cache to at most ZONEINFO_STRONG_CACHE_MAX_SIZE).
*/
static void
-update_strong_cache(const PyTypeObject *const type, PyObject *key,
- PyObject *zone)
+update_strong_cache(zoneinfo_state *state, const PyTypeObject *const type,
+ PyObject *key, PyObject *zone)
{
- if (type != &PyZoneInfo_ZoneInfoType) {
+ if (type != state->ZoneInfoType) {
return;
}
StrongCacheNode *new_node = strong_cache_node_new(key, zone);
-
- move_strong_cache_node_to_front(&ZONEINFO_STRONG_CACHE, new_node);
+ StrongCacheNode **root = &(state->ZONEINFO_STRONG_CACHE);
+ move_strong_cache_node_to_front(state, root, new_node);
StrongCacheNode *node = new_node->next;
for (size_t i = 1; i < ZONEINFO_STRONG_CACHE_MAX_SIZE; ++i) {
* for everything except the base class.
*/
void
-clear_strong_cache(const PyTypeObject *const type)
+clear_strong_cache(zoneinfo_state *state, const PyTypeObject *const type)
{
- if (type != &PyZoneInfo_ZoneInfoType) {
+ if (type != state->ZoneInfoType) {
return;
}
- strong_cache_free(ZONEINFO_STRONG_CACHE);
- ZONEINFO_STRONG_CACHE = NULL;
+ strong_cache_free(state->ZONEINFO_STRONG_CACHE);
+ state->ZONEINFO_STRONG_CACHE = NULL;
}
static PyObject *
return weak_cache;
}
+// This function is not idempotent and must be called on a new module object.
static int
-initialize_caches(void)
+initialize_caches(zoneinfo_state *state)
{
- // TODO: Move to a PyModule_GetState / PEP 573 based caching system.
- if (TIMEDELTA_CACHE == NULL) {
- TIMEDELTA_CACHE = PyDict_New();
- }
- else {
- Py_INCREF(TIMEDELTA_CACHE);
- }
-
- if (TIMEDELTA_CACHE == NULL) {
+ state->TIMEDELTA_CACHE = PyDict_New();
+ if (state->TIMEDELTA_CACHE == NULL) {
return -1;
}
- if (ZONEINFO_WEAK_CACHE == NULL) {
- ZONEINFO_WEAK_CACHE = new_weak_cache();
- }
- else {
- Py_INCREF(ZONEINFO_WEAK_CACHE);
- }
-
- if (ZONEINFO_WEAK_CACHE == NULL) {
+ state->ZONEINFO_WEAK_CACHE = new_weak_cache();
+ if (state->ZONEINFO_WEAK_CACHE == NULL) {
return -1;
}
ZONEINFO_ZONEINFO_CLEAR_CACHE_METHODDEF
ZONEINFO_ZONEINFO_NO_CACHE_METHODDEF
ZONEINFO_ZONEINFO_FROM_FILE_METHODDEF
- {"utcoffset", (PyCFunction)zoneinfo_utcoffset, METH_O,
- PyDoc_STR("Retrieve a timedelta representing the UTC offset in a zone at "
- "the given datetime.")},
- {"dst", (PyCFunction)zoneinfo_dst, METH_O,
- PyDoc_STR("Retrieve a timedelta representing the amount of DST applied "
- "in a zone at the given datetime.")},
- {"tzname", (PyCFunction)zoneinfo_tzname, METH_O,
- PyDoc_STR("Retrieve a string containing the abbreviation for the time "
- "zone that applies in a zone at a given datetime.")},
+ ZONEINFO_ZONEINFO_UTCOFFSET_METHODDEF
+ ZONEINFO_ZONEINFO_DST_METHODDEF
+ ZONEINFO_ZONEINFO_TZNAME_METHODDEF
{"fromutc", (PyCFunction)zoneinfo_fromutc, METH_O,
PyDoc_STR("Given a datetime with local time in UTC, retrieve an adjusted "
"datetime in local time.")},
{"__reduce__", (PyCFunction)zoneinfo_reduce, METH_NOARGS,
PyDoc_STR("Function for serialization with the pickle protocol.")},
- {"_unpickle", (PyCFunction)zoneinfo__unpickle, METH_VARARGS | METH_CLASS,
- PyDoc_STR("Private method used in unpickling.")},
+ ZONEINFO_ZONEINFO__UNPICKLE_METHODDEF
{"__init_subclass__", (PyCFunction)(void (*)(void))zoneinfo_init_subclass,
METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("Function to initialize subclasses.")},
.type = T_OBJECT_EX,
.flags = READONLY,
.doc = NULL},
+ {.name = "__weaklistoffset__",
+ .offset = offsetof(PyZoneInfo_ZoneInfo, weakreflist),
+ .type = T_PYSSIZET,
+ .flags = READONLY},
{NULL}, /* Sentinel */
};
-static PyTypeObject PyZoneInfo_ZoneInfoType = {
- PyVarObject_HEAD_INIT(NULL, 0) //
- .tp_name = "zoneinfo.ZoneInfo",
- .tp_basicsize = sizeof(PyZoneInfo_ZoneInfo),
- .tp_weaklistoffset = offsetof(PyZoneInfo_ZoneInfo, weakreflist),
- .tp_repr = (reprfunc)zoneinfo_repr,
- .tp_str = (reprfunc)zoneinfo_str,
- .tp_getattro = PyObject_GenericGetAttr,
- .tp_flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE),
- /* .tp_doc = zoneinfo_doc, */
- .tp_methods = zoneinfo_methods,
- .tp_members = zoneinfo_members,
- .tp_new = zoneinfo_new,
- .tp_dealloc = zoneinfo_dealloc,
+static PyType_Slot zoneinfo_slots[] = {
+ {Py_tp_repr, zoneinfo_repr},
+ {Py_tp_str, zoneinfo_str},
+ {Py_tp_getattro, PyObject_GenericGetAttr},
+ {Py_tp_methods, zoneinfo_methods},
+ {Py_tp_members, zoneinfo_members},
+ {Py_tp_new, zoneinfo_new},
+ {Py_tp_dealloc, zoneinfo_dealloc},
+ {Py_tp_traverse, zoneinfo_traverse},
+ {Py_tp_clear, zoneinfo_clear},
+ {0, NULL},
+};
+
+static PyType_Spec zoneinfo_spec = {
+ .name = "zoneinfo.ZoneInfo",
+ .basicsize = sizeof(PyZoneInfo_ZoneInfo),
+ .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
+ Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),
+ .slots = zoneinfo_slots,
};
/////
// Specify the _zoneinfo module
static PyMethodDef module_methods[] = {{NULL, NULL}};
-static void
-module_free(void *m)
+
+static int
+module_traverse(PyObject *mod, visitproc visit, void *arg)
{
- Py_CLEAR(_tzpath_find_tzfile);
- Py_CLEAR(_common_mod);
- Py_CLEAR(io_open);
+ zoneinfo_state *state = zoneinfo_get_state(mod);
- xdecref_ttinfo(&NO_TTINFO);
+ Py_VISIT(state->ZoneInfoType);
+ Py_VISIT(state->io_open);
+ Py_VISIT(state->_tzpath_find_tzfile);
+ Py_VISIT(state->_common_mod);
+ Py_VISIT(state->TIMEDELTA_CACHE);
+ Py_VISIT(state->ZONEINFO_WEAK_CACHE);
- if (TIMEDELTA_CACHE != NULL && Py_REFCNT(TIMEDELTA_CACHE) > 1) {
- Py_DECREF(TIMEDELTA_CACHE);
- } else {
- Py_CLEAR(TIMEDELTA_CACHE);
+ StrongCacheNode *node = state->ZONEINFO_STRONG_CACHE;
+ while (node != NULL) {
+ StrongCacheNode *next = node->next;
+ Py_VISIT(node->key);
+ Py_VISIT(node->zone);
+ node = next;
}
- if (ZONEINFO_WEAK_CACHE != NULL && Py_REFCNT(ZONEINFO_WEAK_CACHE) > 1) {
- Py_DECREF(ZONEINFO_WEAK_CACHE);
- } else {
- Py_CLEAR(ZONEINFO_WEAK_CACHE);
- }
+ Py_VISIT(state->NO_TTINFO.utcoff);
+ Py_VISIT(state->NO_TTINFO.dstoff);
+ Py_VISIT(state->NO_TTINFO.tzname);
- clear_strong_cache(&PyZoneInfo_ZoneInfoType);
+ return 0;
+}
+
+static int
+module_clear(PyObject *mod)
+{
+ zoneinfo_state *state = zoneinfo_get_state(mod);
+
+ Py_CLEAR(state->ZoneInfoType);
+ Py_CLEAR(state->io_open);
+ Py_CLEAR(state->_tzpath_find_tzfile);
+ Py_CLEAR(state->_common_mod);
+ Py_CLEAR(state->TIMEDELTA_CACHE);
+ Py_CLEAR(state->ZONEINFO_WEAK_CACHE);
+ clear_strong_cache(state, state->ZoneInfoType);
+ Py_CLEAR(state->NO_TTINFO.utcoff);
+ Py_CLEAR(state->NO_TTINFO.dstoff);
+ Py_CLEAR(state->NO_TTINFO.tzname);
+
+ return 0;
+}
+
+static void
+module_free(void *mod)
+{
+ (void)module_clear((PyObject *)mod);
}
static int
if (PyDateTimeAPI == NULL) {
goto error;
}
- PyZoneInfo_ZoneInfoType.tp_base = PyDateTimeAPI->TZInfoType;
- if (PyType_Ready(&PyZoneInfo_ZoneInfoType) < 0) {
+
+ zoneinfo_state *state = zoneinfo_get_state(m);
+ PyObject *base = (PyObject *)PyDateTimeAPI->TZInfoType;
+ state->ZoneInfoType = (PyTypeObject *)PyType_FromModuleAndSpec(m,
+ &zoneinfo_spec, base);
+ if (state->ZoneInfoType == NULL) {
goto error;
}
- if (PyModule_AddObjectRef(m, "ZoneInfo", (PyObject *)&PyZoneInfo_ZoneInfoType) < 0) {
+ int rc = PyModule_AddObjectRef(m, "ZoneInfo",
+ (PyObject *)state->ZoneInfoType);
+ if (rc < 0) {
goto error;
}
/* Populate imports */
- _tzpath_find_tzfile =
+ state->_tzpath_find_tzfile =
_PyImport_GetModuleAttrString("zoneinfo._tzpath", "find_tzfile");
- if (_tzpath_find_tzfile == NULL) {
+ if (state->_tzpath_find_tzfile == NULL) {
goto error;
}
- io_open = _PyImport_GetModuleAttrString("io", "open");
- if (io_open == NULL) {
+ state->io_open = _PyImport_GetModuleAttrString("io", "open");
+ if (state->io_open == NULL) {
goto error;
}
- _common_mod = PyImport_ImportModule("zoneinfo._common");
- if (_common_mod == NULL) {
+ state->_common_mod = PyImport_ImportModule("zoneinfo._common");
+ if (state->_common_mod == NULL) {
goto error;
}
- if (NO_TTINFO.utcoff == NULL) {
- NO_TTINFO.utcoff = Py_NewRef(Py_None);
- NO_TTINFO.dstoff = Py_NewRef(Py_None);
- NO_TTINFO.tzname = Py_NewRef(Py_None);
+ if (state->NO_TTINFO.utcoff == NULL) {
+ state->NO_TTINFO.utcoff = Py_NewRef(Py_None);
+ state->NO_TTINFO.dstoff = Py_NewRef(Py_None);
+ state->NO_TTINFO.tzname = Py_NewRef(Py_None);
}
- if (initialize_caches()) {
+ if (initialize_caches(state)) {
goto error;
}
{Py_mod_exec, zoneinfomodule_exec}, {0, NULL}};
static struct PyModuleDef zoneinfomodule = {
- PyModuleDef_HEAD_INIT,
+ .m_base = PyModuleDef_HEAD_INIT,
.m_name = "_zoneinfo",
.m_doc = "C implementation of the zoneinfo module",
- .m_size = 0,
+ .m_size = sizeof(zoneinfo_state),
.m_methods = module_methods,
.m_slots = zoneinfomodule_slots,
- .m_free = (freefunc)module_free};
+ .m_traverse = module_traverse,
+ .m_clear = module_clear,
+ .m_free = module_free,
+};
PyMODINIT_FUNC
PyInit__zoneinfo(void)
"Create a ZoneInfo file from a file object.");
#define ZONEINFO_ZONEINFO_FROM_FILE_METHODDEF \
- {"from_file", _PyCFunction_CAST(zoneinfo_ZoneInfo_from_file), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_from_file__doc__},
+ {"from_file", _PyCFunction_CAST(zoneinfo_ZoneInfo_from_file), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_from_file__doc__},
static PyObject *
-zoneinfo_ZoneInfo_from_file_impl(PyTypeObject *type, PyObject *file_obj,
- PyObject *key);
+zoneinfo_ZoneInfo_from_file_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *file_obj, PyObject *key);
static PyObject *
-zoneinfo_ZoneInfo_from_file(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+zoneinfo_ZoneInfo_from_file(PyTypeObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
key = args[1];
skip_optional_pos:
- return_value = zoneinfo_ZoneInfo_from_file_impl(type, file_obj, key);
+ return_value = zoneinfo_ZoneInfo_from_file_impl(type, cls, file_obj, key);
exit:
return return_value;
"Get a new instance of ZoneInfo, bypassing the cache.");
#define ZONEINFO_ZONEINFO_NO_CACHE_METHODDEF \
- {"no_cache", _PyCFunction_CAST(zoneinfo_ZoneInfo_no_cache), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_no_cache__doc__},
+ {"no_cache", _PyCFunction_CAST(zoneinfo_ZoneInfo_no_cache), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_no_cache__doc__},
static PyObject *
-zoneinfo_ZoneInfo_no_cache_impl(PyTypeObject *type, PyObject *key);
+zoneinfo_ZoneInfo_no_cache_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *key);
static PyObject *
-zoneinfo_ZoneInfo_no_cache(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+zoneinfo_ZoneInfo_no_cache(PyTypeObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
goto exit;
}
key = args[0];
- return_value = zoneinfo_ZoneInfo_no_cache_impl(type, key);
+ return_value = zoneinfo_ZoneInfo_no_cache_impl(type, cls, key);
exit:
return return_value;
"Clear the ZoneInfo cache.");
#define ZONEINFO_ZONEINFO_CLEAR_CACHE_METHODDEF \
- {"clear_cache", _PyCFunction_CAST(zoneinfo_ZoneInfo_clear_cache), METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_clear_cache__doc__},
+ {"clear_cache", _PyCFunction_CAST(zoneinfo_ZoneInfo_clear_cache), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo_clear_cache__doc__},
static PyObject *
-zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyObject *only_keys);
+zoneinfo_ZoneInfo_clear_cache_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *only_keys);
static PyObject *
-zoneinfo_ZoneInfo_clear_cache(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+zoneinfo_ZoneInfo_clear_cache(PyTypeObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
}
only_keys = args[0];
skip_optional_kwonly:
- return_value = zoneinfo_ZoneInfo_clear_cache_impl(type, only_keys);
+ return_value = zoneinfo_ZoneInfo_clear_cache_impl(type, cls, only_keys);
exit:
return return_value;
}
-/*[clinic end generated code: output=d2da73ef66146b83 input=a9049054013a1b77]*/
+
+PyDoc_STRVAR(zoneinfo_ZoneInfo_utcoffset__doc__,
+"utcoffset($self, dt, /)\n"
+"--\n"
+"\n"
+"Retrieve a timedelta representing the UTC offset in a zone at the given datetime.");
+
+#define ZONEINFO_ZONEINFO_UTCOFFSET_METHODDEF \
+ {"utcoffset", _PyCFunction_CAST(zoneinfo_ZoneInfo_utcoffset), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zoneinfo_ZoneInfo_utcoffset__doc__},
+
+static PyObject *
+zoneinfo_ZoneInfo_utcoffset_impl(PyObject *self, PyTypeObject *cls,
+ PyObject *dt);
+
+static PyObject *
+zoneinfo_ZoneInfo_utcoffset(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "utcoffset",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *dt;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ dt = args[0];
+ return_value = zoneinfo_ZoneInfo_utcoffset_impl(self, cls, dt);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zoneinfo_ZoneInfo_dst__doc__,
+"dst($self, dt, /)\n"
+"--\n"
+"\n"
+"Retrieve a timedelta representing the amount of DST applied in a zone at the given datetime.");
+
+#define ZONEINFO_ZONEINFO_DST_METHODDEF \
+ {"dst", _PyCFunction_CAST(zoneinfo_ZoneInfo_dst), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zoneinfo_ZoneInfo_dst__doc__},
+
+static PyObject *
+zoneinfo_ZoneInfo_dst_impl(PyObject *self, PyTypeObject *cls, PyObject *dt);
+
+static PyObject *
+zoneinfo_ZoneInfo_dst(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "dst",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *dt;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ dt = args[0];
+ return_value = zoneinfo_ZoneInfo_dst_impl(self, cls, dt);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zoneinfo_ZoneInfo_tzname__doc__,
+"tzname($self, dt, /)\n"
+"--\n"
+"\n"
+"Retrieve a string containing the abbreviation for the time zone that applies in a zone at a given datetime.");
+
+#define ZONEINFO_ZONEINFO_TZNAME_METHODDEF \
+ {"tzname", _PyCFunction_CAST(zoneinfo_ZoneInfo_tzname), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, zoneinfo_ZoneInfo_tzname__doc__},
+
+static PyObject *
+zoneinfo_ZoneInfo_tzname_impl(PyObject *self, PyTypeObject *cls,
+ PyObject *dt);
+
+static PyObject *
+zoneinfo_ZoneInfo_tzname(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "tzname",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[1];
+ PyObject *dt;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ dt = args[0];
+ return_value = zoneinfo_ZoneInfo_tzname_impl(self, cls, dt);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zoneinfo_ZoneInfo__unpickle__doc__,
+"_unpickle($type, key, from_cache, /)\n"
+"--\n"
+"\n"
+"Private method used in unpickling.");
+
+#define ZONEINFO_ZONEINFO__UNPICKLE_METHODDEF \
+ {"_unpickle", _PyCFunction_CAST(zoneinfo_ZoneInfo__unpickle), METH_METHOD|METH_FASTCALL|METH_KEYWORDS|METH_CLASS, zoneinfo_ZoneInfo__unpickle__doc__},
+
+static PyObject *
+zoneinfo_ZoneInfo__unpickle_impl(PyTypeObject *type, PyTypeObject *cls,
+ PyObject *key, unsigned char from_cache);
+
+static PyObject *
+zoneinfo_ZoneInfo__unpickle(PyTypeObject *type, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+ PyObject *return_value = NULL;
+ #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+ # define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
+ #else
+ # define KWTUPLE NULL
+ #endif
+
+ static const char * const _keywords[] = {"", "", NULL};
+ static _PyArg_Parser _parser = {
+ .keywords = _keywords,
+ .fname = "_unpickle",
+ .kwtuple = KWTUPLE,
+ };
+ #undef KWTUPLE
+ PyObject *argsbuf[2];
+ PyObject *key;
+ unsigned char from_cache;
+
+ args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ if (!args) {
+ goto exit;
+ }
+ key = args[0];
+ {
+ unsigned long ival = PyLong_AsUnsignedLongMask(args[1]);
+ if (ival == (unsigned long)-1 && PyErr_Occurred()) {
+ goto exit;
+ }
+ else {
+ from_cache = (unsigned char) ival;
+ }
+ }
+ return_value = zoneinfo_ZoneInfo__unpickle_impl(type, cls, key, from_cache);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=54051388dfc408af input=a9049054013a1b77]*/
projects / thirdparty / Python / cpython.git / commitdiff
