def __new__( cls, data, closed=None, dtype: Optional[Dtype] = None, copy: bool = False, name=None, verify_integrity: bool = True, ): name = maybe_extract_name(name, data, cls) with rewrite_exception("IntervalArray", cls.__name__): array = IntervalArray( data, closed=closed, copy=copy, dtype=dtype, verify_integrity=verify_integrity, ) return cls._simple_new(array, name)
def __new__( cls, data=None, categories=None, ordered=None, dtype: Optional[Dtype] = None, copy=False, name=None, ): name = maybe_extract_name(name, data, cls) if is_scalar(data): raise cls._scalar_data_error(data) data = Categorical(data, categories=categories, ordered=ordered, dtype=dtype, copy=copy) return cls._simple_new(data, name=name)
def __new__( cls, data=None, categories=None, ordered=None, dtype: Dtype | None = None, copy: bool = False, name: Hashable = None, ) -> CategoricalIndex: name = maybe_extract_name(name, data, cls) if is_scalar(data): raise cls._scalar_data_error(data) data = Categorical(data, categories=categories, ordered=ordered, dtype=dtype, copy=copy) return cls._simple_new(data, name=name)
def __new__( cls, data=None, freq=None, tz=None, normalize=False, closed=None, ambiguous="raise", dayfirst=False, yearfirst=False, dtype=None, copy=False, name=None, ): if is_scalar(data): raise TypeError( f"{cls.__name__}() must be called with a " f"collection of some kind, {repr(data)} was passed" ) # - Cases checked above all return/raise before reaching here - # name = maybe_extract_name(name, data, cls) dtarr = DatetimeArray._from_sequence( data, dtype=dtype, copy=copy, tz=tz, freq=freq, dayfirst=dayfirst, yearfirst=yearfirst, ambiguous=ambiguous, ) subarr = cls._simple_new(dtarr, name=name) return subarr
def __new__( cls, data=None, unit=None, freq=lib.no_default, closed=None, dtype=TD64NS_DTYPE, copy=False, name=None, ): name = maybe_extract_name(name, data, cls) if is_scalar(data): raise cls._scalar_data_error(data) if unit in {"Y", "y", "M"}: raise ValueError( "Units 'M', 'Y', and 'y' are no longer supported, as they do not " "represent unambiguous timedelta values durations." ) if isinstance(data, TimedeltaArray) and freq is lib.no_default: if copy: data = data.copy() return cls._simple_new(data, name=name) if isinstance(data, TimedeltaIndex) and freq is lib.no_default and name is None: if copy: return data.copy() else: return data._view() # - Cases checked above all return/raise before reaching here - # tdarr = TimedeltaArray._from_sequence_not_strict( data, freq=freq, unit=unit, dtype=dtype, copy=copy ) return cls._simple_new(tdarr, name=name)
def __new__( cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None ): dtype = CategoricalDtype._from_values_or_dtype(data, categories, ordered, dtype) name = maybe_extract_name(name, data, cls) if not is_categorical_dtype(data): # don't allow scalars # if data is None, then categories must be provided if is_scalar(data): if data is not None or categories is None: raise cls._scalar_data_error(data) data = [] assert isinstance(dtype, CategoricalDtype), dtype if not isinstance(data, Categorical) or data.dtype != dtype: data = Categorical(data, dtype=dtype) data = data.copy() if copy else data return cls._simple_new(data, name=name)
def __new__( cls, start=None, stop=None, step=None, dtype: Optional[Dtype] = None, copy=False, name=None, ): cls._validate_dtype(dtype) name = maybe_extract_name(name, start, cls) # RangeIndex if isinstance(start, RangeIndex): return start.copy(name=name) elif isinstance(start, range): return cls._simple_new(start, name=name) # validate the arguments if com.all_none(start, stop, step): raise TypeError("RangeIndex(...) must be called with integers") start = ensure_python_int(start) if start is not None else 0 if stop is None: start, stop = 0, start else: stop = ensure_python_int(stop) step = ensure_python_int(step) if step is not None else 1 if step == 0: raise ValueError("Step must not be zero") rng = range(start, stop, step) return cls._simple_new(rng, name=name)
def __new__(cls, data=None, categories=None, ordered=None, dtype=None, copy=False, name=None): name = maybe_extract_name(name, data, cls) if is_scalar(data): # don't allow scalars # if data is None, then categories must be provided if data is not None or categories is None: raise cls._scalar_data_error(data) data = [] data = Categorical(data, categories=categories, ordered=ordered, dtype=dtype, copy=copy) return cls._simple_new(data, name=name)
def __new__( cls, data=None, ordinal=None, freq=None, tz=None, dtype=None, copy=False, name=None, **fields, ): valid_field_set = { "year", "month", "day", "quarter", "hour", "minute", "second", } if not set(fields).issubset(valid_field_set): argument = list(set(fields) - valid_field_set)[0] raise TypeError( f"__new__() got an unexpected keyword argument {argument}") name = maybe_extract_name(name, data, cls) if data is None and ordinal is None: # range-based. data, freq2 = PeriodArray._generate_range(None, None, None, freq, fields) # PeriodArray._generate range does validation that fields is # empty when really using the range-based constructor. freq = freq2 data = PeriodArray(data, freq=freq) else: freq = validate_dtype_freq(dtype, freq) # PeriodIndex allow PeriodIndex(period_index, freq=different) # Let's not encourage that kind of behavior in PeriodArray. if freq and isinstance(data, cls) and data.freq != freq: # TODO: We can do some of these with no-copy / coercion? # e.g. D -> 2D seems to be OK data = data.asfreq(freq) if data is None and ordinal is not None: # we strangely ignore `ordinal` if data is passed. ordinal = np.asarray(ordinal, dtype=np.int64) data = PeriodArray(ordinal, freq) else: # don't pass copy here, since we copy later. data = period_array(data=data, freq=freq) if copy: data = data.copy() return cls._simple_new(data, name=name)
def __new__(cls, data=None, dtype: Optional[Dtype] = None, copy=False, name=None): name = maybe_extract_name(name, data, cls) subarr = cls._ensure_array(data, dtype, copy) return cls._simple_new(subarr, name=name)