>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt","for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if","observation location from which to apply the constraints targets : sequence of `~astroplan.Target`","apply the constraints. Returns ------- constraint_result : 2D array of float or bool","def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min,","= (vals - min_val) / (max_val - min_val) below = vals < min_val","max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the location","| moon_down_mask elif self.max is None and self.min is not None: mask =","time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1)","the real work of computing the constraint. Subclasses override this. Parameters ---------- times","__init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : float or `None` (optional)","of a minimum of 0.65 and no maximum Parameters ---------- min : float","if self.min is None and self.max is None: raise ValueError(\"You must at least","be within certain time limits. An example use case for this class would","operations are relatively slow # but there is potential for huge speedup if","0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint must be","less_than_min : 0 or 1 what is returned for ``vals`` below ``min_val``. (in","& (illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No max and/or min specified","`~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain the","applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing),","`~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are","`~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the observaton location",": float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no","time limits used in calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None,","constraint is treated as a boolean (True for within the limits and False","try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative","self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be","dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return","lower limit. Parameters ---------- max : float or `None` Maximum airmass of the","`None` indicates no limit. Examples -------- Constrain the observations to targets that are","constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None,","else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a","`None` indicates no limit. \"\"\" self.min = min self.max = max def compute_constraint(self,","or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to","Default is one. Examples -------- To constrain observations on orbital phases between 0.4","value cared about (rescales to 1) less_than_min : 0 or 1 what is","# quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else:","def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive).","is considered to be \"night\" (inclusive). force_pressure_zero : bool (optional) Force the pressure","`~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum Parameters ----------","axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is","constraints targets : sequence of `~astroplan.Target` The targets on which to apply the","the frame data should be unique and is # quicker than accessing the","about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and","0. , 0. , 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled = (vals","evaluating multiple constraints. if targets.isscalar: # ensure we have a (1, 1) shape","to store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array","of these objects. We make # to simple numpy arrays of the same","The altitude of the sun below which it is considered to be \"night\"","---------- observer : `~astroplan.Observer` the observation location from which to apply the constraints","targets): # removed the location argument here, which causes small <1 deg #","subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50 and 04:08 local","PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be described on the","``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict : dict","To constrain observations on orbital phases between 0.6 and 1.2, for example, you","on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of","is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table:","airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min =","time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name',","(optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max","observations on orbital phases between 0.6 and 1.2, for example, you should subtract","the location argument here, which causes small <1 deg # innacuracies, but it","\"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time(","None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask =","appear in the order (max, min) in this initializer to support the common","35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8,","= moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if","_get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit for an array of times","twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between astronomical twilights (-18 degrees). \"\"\"","from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as","if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\")","constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr =","rescaled = (vals - min_val) / (max_val - min_val) below = vals <",">>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. ,","determine which targets are observable for an observer. \"\"\" from __future__ import (absolute_import,","= max def compute_constraint(self, times, observer, targets): # use get_body rather than get","None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time","for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer,","\"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\")","class Parameters ---------- observer : `~astroplan.Observer` the observation location from which to apply","attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string.","Dictionary containing two key-value pairs. (1) 'times' contains the times for the alt/az","min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below","below = vals < min_val above = vals > max_val rescaled[below] = 0","\"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times,","import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod","raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint):","observer._moon_cache = {} # convert times to tuple for hashing aakey = _make_cache_key(times,","who care about the upper limit on the airmass (``max``) and not the","else: raise ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask class","constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1]","BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower","the sun below which it is considered to be \"night\" (inclusive). force_pressure_zero :","between 23:50 and 04:08 local time: >>> from astroplan import Observer >>> from","targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is","Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max,","doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \"\"\" rescaled","= [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable","1 what is returned for ``vals`` above ``max_val``. (in some cases anything higher","<= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint):","self.min is not None: mask = self.min <= secz elif self.min is not","interval [0, 1). Default is one. Examples -------- To constrain observations on orbital","which is GCRS, and that is what we want. moon_separation = moon.separation(targets) if","`None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max :","information about observability for all the ``targets`` over the requested ``time_range``, given the","if times is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution)","compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make","alt/az for ``target`` at times linearly spaced between the two times in ``time_range``","indicates no limit. Examples -------- Constrain the observations to targets that are observable","separation elif self.max is None and self.min is not None: mask = self.min","= self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary","None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets","constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ----------","from # broadcasting times and targets against each other if targets is not","times : `~astropy.time.Time` Array of times on which to test the constraint observer","\"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse.","used in calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\"","1) or (max < 0) or (max > 1): raise ValueError('The minimum of","``observer``` object. This routine will provide an appropriate, hashable, key to store these","limits must be specified as datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone","{} # convert times to tuple for hashing aakey = _make_cache_key(times, targets) if","59) # If time limits occur on same day: if min_time < max_time:","example use case for this class would be to associate an acceptable time","along the first index and times along the second. \"\"\" # Should be","altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution)","to be a score (between zero and one), where the ``min_val`` goes to","\"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\",","specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore')","and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the","np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the","for users who care about the upper limit on the airmass (``max``) and","**kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {}","times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not","constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN","self.max is not None: max_time = self.max else: max_time = datetime.time(23, 59, 59)","on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether","Constrain the distance between the Sun and some targets. \"\"\" def __init__(self, min=None,","indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between","constraints, with targets along the first index and times along the second. \"\"\"","is None and self.max is not None: mask = secz <= self.max elif","try: mask = np.array([min_time <= t.time() <= max_time for t in times.datetime]) except","else self.min # values below 1 should be disregarded return min_best_rescale(secz, mi, mx,","= np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\"","always_obs, frac_obs]) if times is None and time_range is not None: times =","(optional) Array of ingress and egress times for ``N`` events, with shape (``N``,","and a maximum of 0.65 Parameters ---------- min : float or `None` (optional)","# needed for backward compatibility _current_year_time_range = Time( # needed for backward compatibility","altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False):","``min_val`` should also return one, in some cases it should return zero) Returns","within the limits and False for outside). If False, the constraint returns a","altitudes to be between 0 and 1, with the best (60) going to","is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape","float or `None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint","(-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime","the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times.",": bool if True, grids the constraint result with targets along the first","elif self.min is not None and self.max is not None: mask = (self.min","= altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero:","that are observable between 23:50 and 04:08 local time: >>> from astroplan import","np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException:",": `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest","phase. For example, the system could be an eclipsing or non-eclipsing binary, or","None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these",": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times","object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints","\"\"\" self.min = min self.max = max def compute_constraint(self, times, observer, targets): #","04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint","current implementation the airmass is approximated by the secant of the zenith angle.","is not None: timezone = self.min.tzinfo elif self.max is not None: timezone =","ever observable at each time, given the constraints. \"\"\" if not hasattr(constraints, '__len__'):","each target is observable in the time range given the constraints. \"\"\" if","(optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min,","else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t","targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b =","has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min :","binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum","targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets`` are always","(optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max : float","index and times along the second. \"\"\" if times is None and time_range","force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary","max_time = self.max else: max_time = datetime.time(23, 59, 59) # If time limits","``min_val`` goes to zero. Parameters ---------- vals : array-like the values that need","max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30, 40, 45,","bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two","bool The constraints. If 2D with targets along the first index and times","re-shapes the coords themselves # prior to evaluating multiple constraints. if targets.isscalar: #","time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a lot by","observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else","if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple","@abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually do the real work of","alt/az coordinates at those times and (3) contains the moon illumination for those","= observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract","1). To constrain observations on orbital phases between 0.6 and 1.2, for example,","frame data should be unique and is # quicker than accessing the ra","except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask","acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`","values outside the range should return 0. >>> from astroplan.constraints import min_best_rescale >>>","0 or 1 what is returned for ``vals`` above ``max_val``. (in some cases","(moon_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\")","Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max","not all observing blocks are valid over the time limits used in calls","in the order (max, min) in this initializer to support the common case","the fractional illumination of the Earth's moon. Constraint is also satisfied if the","indicates no limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets):","to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is","def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit for an array of","the Galactic plane and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters","separation between moon and target (inclusive). `None` indicates no limit. ephemeris : str,","Sun and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min","hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey","warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\")","None: mask = (self.max >= illumination) | moon_down_mask elif self.max is None and","rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1):","in \" \"AirmassConstraint.\") return mask else: if self.max is None: raise ValueError(\"Cannot have","and worst (35) going to 0. For values outside the range, the rescale","0. , 0. ]) \"\"\" rescaled = (vals - max_val) / (min_val -","``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints]","mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below ``horizon``. \"\"\"","which targets are observable for an observer. \"\"\" from __future__ import (absolute_import, division,","is not None and self.max is not None: mask = ((self.min <= illumination)","else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude =","the observability information for each of the ``targets``. The table contains four columns","None: mask = (self.min <= secz) & (secz <= self.max) else: raise ValueError(\"No","is None: raise ValueError(\"You must at least supply either a minimum or a","degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as","def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be","huge speedup if the end user # disables gridding and re-shapes the coords","max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65",".. note:: This can misbehave if you try to constrain negative altitudes, as","(solar_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\")","as a SkyCoord object. Accessing the longitude # attribute of the frame data","[0, 1). Default is one. Examples -------- To constrain observations on orbital phases","min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates","the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\"","0 and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to","return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun and some","observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets`` are","mask = (self.min <= illumination) & moon_up_mask elif self.min is not None and","the coords themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure","AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper","= np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of time","min altitude and 1 is the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True):","are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular","def compute_constraint(self, times, observer, targets): # removed the location argument here, which causes","\"\"\" Constrain the observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ----------","spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution","to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of","targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output has","None and self.max is not None: mask = ((self.min <= separation) & (separation","for ``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters ----------","Abstract class for objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self,","than ``max_val`` should also return one, in some cases it should return zero)","compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max","and targets against each other if targets is not None: # broadcasting times","rather than get sun here, since # it returns the Sun's coordinates in","= datetime.time(23, 59, 59) # If time limits occur on same day: if","in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:,","# the former calculates the separation in the frame of the moon coord","timekey = (times.jd,) # make hashable thing from targets coords try: if hasattr(targets,","for whether or not each target is observable in the time range given","for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer,","observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will also be","of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or","rely on broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result","in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`","target. `None` indicates no limit. min : float or `None` Minimum airmass of","0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally:","`~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``. This","times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val,","3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([","max=0.6) The minimum and maximum phase must be described on the interval [0,","``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters ---------- vals","return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit for an","observer, targets): timezone = None # get timezone from time objects, or from","system. min : float (optional) Minimum phase (inclusive) on interval [0, 1). Default","self.max else: max_time = datetime.time(23, 59, 59) # If time limits occur on","information for each of the ``targets``. The table contains four columns with information","max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase =",", 0. ]) \"\"\" rescaled = (vals - max_val) / (min_val - max_val)","along the first index and times along the second. \"\"\" if times is","(in some cases anything less than ``min_val`` should also return one, in some","& (secz <= self.max) else: raise ValueError(\"No max and/or min specified in \"","None and self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation","of same length as ``targets`` for whether or not each target is ever","= (self.min <= illumination) & moon_up_mask elif self.min is not None and self.max","observable at each time in ``times``, given constraints in ``constraints`` for a particular","unique and is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel())","of 0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional","`None` Minimum altitude of the target (inclusive). `None` indicates no limit. max :","boolean_constraint : bool If True, the constraint is treated as a boolean (True","self.min = min if max is None: self.max = 90*u.deg else: self.max =","# find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude =","@classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of","ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\"","times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH","and self.max is None: raise ValueError(\"You must at least supply either a minimum","and a maximum of 0.25 Parameters ---------- min : float or `None` (optional)","class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary eclipse. \"\"\" def __init__(self,","0.65 and no maximum Parameters ---------- min : float or `None` (optional) Minimum","NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target. .. note:: This","of a minimum of 0.25 and a maximum of 0.65 Parameters ---------- min","``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution :","if self.min is None and self.max is not None: mask = secz <=","(60) going to 1 and worst (35) going to 0. For values outside","the first index and times along the second. \"\"\" if times is None","observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey = _make_cache_key(times,","def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between civil twilights (-6 degrees).","if self.boolean_constraint: if self.min is None and self.max is not None: mask =","separation) & (separation <= self.max)) else: raise ValueError(\"No max and/or min specified in",": `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the","_make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] =","deg # innacuracies, but it is needed until astropy PR #5897 is released","(inclusive) on interval [0, 1). Default is zero. max : float (optional) Maximum","max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def",": float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no","axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs,","to 0) max_val : float best value cared about (rescales to 1) less_than_min","return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the",": `~astropy.time.Time` Array of times on which to test the constraint. targets :","is zero. max : float (optional) Maximum phase (inclusive) on interval [0, 1).","targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or","float AirmassConstraint if max is None.\") else: mx = self.max mi = 1","moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and self.max is","if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\"Time limits must","which to compute the phase. For example, the system could be an eclipsing","hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints = [constraint(observer,","+ '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a unique key to reference","\"night\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for solar","is None and self.max is not None: mask = (self.max >= illumination) |","are relatively slow # but there is potential for huge speedup if the","\"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed","**kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between astronomical twilights","= tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer","targets is slow due to # complex nature of these objects. We make","which to test the constraint. observer : `~astroplan.Observer` The observer who has constraints","# note to future editors - the order matters here # moon.separation(targets) is","0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled = (vals - min_val) / (max_val","test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets.","targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable during ``time_range``","abstractmethod import datetime import time import warnings # Third-party from astropy.time import Time","= Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min =","etc. \"\"\" # TODO: This method could be sped up a lot by","\"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\",","None and self.min is not None: mask = self.min <= solar_separation elif self.min","of altitudes to be between 0 and 1, with the best (60) going","sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the","axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is","and the ``max_val`` goes to zero. Parameters ---------- vals : array-like the values","tuple for use as a cache key \"\"\" # make a tuple from",": 0 or 1 what is returned for ``vals`` below ``min_val``. (in some","self.max is not None: mask = self.max >= solar_separation elif self.max is None","lowermask = self.min <= alt uppermask = alt <= self.max return lowermask &","(inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def grey(cls,","Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max if","on time sequence If ``time_range`` is not specified, defaults to current year (localtime)","times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable during ``time_range`` given","altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude","limit. boolean_constraint : bool If True, the constraint is treated as a boolean","= dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for objects defining","limit. ephemeris : str, optional Ephemeris to use. If not given, use the","# needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def","\"\"\" Calculate alt/az for ``target`` at times linearly spaced between the two times","observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times,","return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary eclipse. \"\"\"","= moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and self.max","times along the second. \"\"\" if times is None and time_range is not","is also satisfied if the Moon has set. \"\"\" def __init__(self, min=None, max=None,","This routine will provide an appropriate, hashable, key to store these calculations in","to be between 0 and 1, with the best (60) going to 1","targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min","quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: #","for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None,","# If time limits occur on same day: if min_time < max_time: try:","min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min =","be for a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity`","u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table","**kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and","(illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No max and/or min specified in","= PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and",">= self.min) & (phase <= self.max), (phase >= self.min) | (phase <= self.max))","the corresponding alt/az coordinates at those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache","Constrain observations to times during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters","times and (3) contains the moon illumination for those times. \"\"\" if not","is not None: mask = secz <= self.max elif self.max is None and","self.max = max def compute_constraint(self, times, observer, targets): # use get_body rather than","mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Earth's moon and some","altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure","times : `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the",">= separation elif self.max is None and self.min is not None: mask =","= moon.separation(targets) if self.min is None and self.max is not None: mask =","max_val, less_than_min=1): \"\"\" rescales an input array ``vals`` to be a score (between","``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val`` equal 1","= as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2))","Minimum altitude of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`","of no minimum and a maximum of 0.25 Parameters ---------- min : float","constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns -------","time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range,","times on which to test the constraint. observer : `~astroplan.Observer` The observer who","If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or","a SkyCoord object. Accessing the longitude # attribute of the frame data should","certain time limits. An example use case for this class would be to","time_grid_resolution) # TODO: This method could be sped up a lot by dropping","mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the Earth's moon. Constraint","and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between","min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and","(2.25). All values outside the range should return 0. >>> from astroplan.constraints import","is None: timezone = observer.timezone if self.min is not None: min_time = self.min","always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames,","some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min :","target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True)","is not None: mask = self.min <= moon_separation elif self.min is not None","self.min = min self.max = max def compute_constraint(self, times, observer, targets): # use","self.min is None and self.max is not None: mask = self.max >= moon_separation","Accessing the longitude # attribute of the frame data should be unique and","want. moon_separation = moon.separation(targets) if self.min is None and self.max is not None:","= (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate","times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations","times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to","time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this class Parameters ---------- observer","and upper bounds on time sequence, with spacing ``time_resolution``. This will be passed","= self.min <= moon_separation elif self.min is not None and self.max is not","the time limits used in calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self,","= self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase <=","altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if","shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result","given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints =","objects.\") if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits","``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of","``times`` in a cache on an ``observer``` object. This routine will provide an","what is returned for ``vals`` above ``max_val``. (in some cases anything higher than","self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between","the upper limit on the airmass (``max``) and not the lower limit. Parameters","no limit. \"\"\" self.min = min self.max = max def compute_constraint(self, times, observer,","aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0","Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional","max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain","\"\"\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls,","use get_body rather than get sun here, since # it returns the Sun's","Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint observer :","a minimum of 0.65 and no maximum Parameters ---------- min : float or","2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0.","+ targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at","constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time`","fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to","with grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object.","target is ever observable at each time, given the constraints. \"\"\" if not","0.2, 0. , 0. ]) \"\"\" rescaled = (vals - max_val) / (min_val","``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``.","<= self.max elif self.max is None and self.min is not None: mask =","time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for","observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def","float or `None` Maximum airmass of the target. `None` indicates no limit. min","of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied","work of computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time`","to support the common case for users who care about the upper limit","return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between","= eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class","SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on time","Often, we wish to store expensive calculations for a combination of ``targets`` and","(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable","<= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No max and/or","\"\"\" # make a tuple from times try: timekey = tuple(times.jd) + times.shape","note to future editors - the order matters here # moon.separation(targets) is NOT","------- array of floats between 0 and 1 inclusive rescaled so that ``vals``","a combination of ``targets`` and ``times`` in a cache on an ``observer``` object.","constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing","override this. Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint","into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints","the table will be for a 24 hour period centered on that time.","times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is","if (min < 0) or (min > 1) or (max < 0) or","coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the","the ``max_val`` goes to zero. Parameters ---------- vals : array-like the values that","min if max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint","# make a tuple from times try: timekey = tuple(times.jd) + times.shape except","self.max is not None: mask = ((self.min <= illumination) & (illumination <= self.max))","moon_down_mask elif self.max is None and self.min is not None: mask = (self.min","vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals,","metadata entries ``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer`","None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr =","is None and self.min is not None: mask = self.min <= moon_separation elif",".utils import time_grid_from_range from .target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\",","bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three","\" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time =","an ``observer``` object. This routine will provide an appropriate, hashable, key to store","compute_constraint(self, times, observer, targets): # removed the location argument here, which causes small","and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional)","(optional) Minimum phase (inclusive) on interval [0, 1). Default is zero. max :","a unique key to reference this combination of ``times`` and ``targets``. Often, we","pairs. (1) 'times' contains the times for the alt/az computations, (2) 'altaz' contains","and False for outside). If False, the constraint returns a float on [0,","a float AirmassConstraint if max is None.\") else: mx = self.max mi =","optional Ephemeris to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set``","problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle","observing time to be within certain time limits. An example use case for","argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether","same length as ``times`` for whether or not the target is ever observable","between 0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal","style license - see LICENSE.rst \"\"\" Specify and constraints to determine which targets","The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times","self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer,","columns with information about the target and it's observability: ``'target name'``, ``'ever observable'``,","min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if","The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or","observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min)","``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List of booleans","to ``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples --------","targets that are observable between 23:50 and 04:08 local time: >>> from astroplan","first index and times along the second. \"\"\" if times is None and","is not None: mask = (self.min <= illumination) & moon_up_mask elif self.min is","max=0.2) \"\"\" self.periodic_event = periodic_event if (min < 0) or (min > 1)","representing each month that a target is observable, one set per target. These","relatively slow # but there is potential for huge speedup if the end","(optional) If ``time_range`` is specified, determine whether constraints are met between test times","constraint result with targets along the first index and times along the second.",": float (optional) Minimum phase (inclusive) on interval [0, 1). Default is zero.","= targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer,","35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy","targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict","(self.min <= secz) & (secz <= self.max) else: raise ValueError(\"No max and/or min","[str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a","tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times","observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at these times","self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime","observations to targets that are observable between 23:50 and 04:08 local time: >>>","worst (2.25). All values outside the range should return 0. >>> from astroplan.constraints","two key-value pairs. (1) 'times' contains the times for the alt/az computations, (2)","these objects. We make # to simple numpy arrays of the same shape","_get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and","min if min is not None else 0.0 self.max = max if max","\"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc","by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times,","convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not","are 1-based so that January maps to 1, February maps to 2, etc.","of targets. Returns ------- cache_key : tuple A hashable tuple for use as","linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table :","a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25 Parameters","= max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as","met between test times in ``time_range`` by checking constraint at linearly-spaced times separated","sure the output has the same shape as would result from # broadcasting","= Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max","= np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain","return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination","max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary eclipse.","than ``min_val`` should also return one, in some cases it should return zero)","= times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val,","= solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between","SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system):","constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times","= observer.pressure observer.pressure = 0 # find solar altitude at these times altaz","min_val) below = vals < min_val above = vals > max_val rescaled[below] =","target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum","is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times)","<= moon_separation elif self.min is not None and self.max is not None: mask","self.min is not None: mask = (self.min <= illumination) & moon_up_mask elif self.min","# convert times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey","secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask =","except BaseException: # must be scalar timekey = (times.jd,) # make hashable thing","= min self.max = max def compute_constraint(self, times, observer, targets): # use get_body","times try: timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar","# but there is potential for huge speedup if the end user #","= times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints]","= _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey]","arguments appear in the order (max, min) in this initializer to support the","shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times,","by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List of",": float or `None` Minimum airmass of the target. `None` indicates no limit.","some cases it should return zero) Returns ------- array of floats between 0","max_time for t in times.datetime]) except BaseException: # use np.bool so shape queries","1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and those","(self.min <= illumination) & moon_up_mask elif self.min is not None and self.max is","must be specified as \" \"astropy.time.Time objects.\") if self.max is not None: if","time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed for backward","or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase (inclusive)","this combination of ``times`` and ``targets``. Often, we wish to store expensive calculations","{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict","the Earth's moon. Constraint is also satisfied if the Moon has set. \"\"\"","not None: mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask","time limits. An example use case for this class would be to associate","(vals - max_val) / (min_val - max_val) below = vals < min_val above","not each target is observable in the time range given the constraints. \"\"\"","or bool The constraints, with targets along the first index and times along","along the second. \"\"\" if times is None and time_range is not None:",": str, optional Ephemeris to use. If not given, use the one set","months_observable = [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for","aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets)","defaults of no minimum and a maximum of 0.25 Parameters ---------- min :","self.max is not None: if not isinstance(self.max, Time): raise TypeError(\"Time limits must be","and times along the second. Otherwise, we rely on broadcasting the shapes together","cared about (rescales to 1) greater_than_max : 0 or 1 what is returned","unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime import time","anything higher than ``max_val`` should also return one, in some cases it should","at times linearly spaced between the two times in ``time_range`` with grid spacing","eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times)","az and illumination for an array of times for ``observer``. Cache the result","an array of times for ``observer``. Cache the result on the ``observer`` object.","astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided # Package","\"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time","key-value pair. 'times' contains the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache","civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\"","goes to one, and the ``min_val`` goes to zero. Parameters ---------- vals :","for atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero","from times try: timekey = tuple(times.jd) + times.shape except BaseException: # must be","or (min > 1) or (max < 0) or (max > 1): raise","subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\"","equal 1 Examples -------- rescale an array of altitudes to be between 0","bool Examples -------- To create a constraint that requires the airmass be \"better","self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\"","observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] =","``min_val``. (in some cases anything less than ``min_val`` should also return one, in","some cases anything higher than ``max_val`` should also return one, in some cases","calculations for a combination of ``targets`` and ``times`` in a cache on an","rescaled = (vals - max_val) / (min_val - max_val) below = vals <","= times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1))","and/or min specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the","computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times and (3)","on interval [0, 1). Default is one. Examples -------- To constrain observations on","output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times,","times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times,","entries ``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object),","a cache on an ``observer``` object. This routine will provide an appropriate, hashable,","[constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up","the specified ``targets`` are observable for a specific ``observer``, given the supplied ``constraints``.","Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \"\"\"","see LICENSE.rst \"\"\" Specify and constraints to determine which targets are observable for","def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else:","from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20,","secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not","-------- rescale airmasses to between 0 and 1, with the best (1) and","max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with",": 0 or 1 what is returned for ``vals`` above ``max_val``. (in some","> min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to","targets along the first index and times along the second. \"\"\" # Should","be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain","import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>>","which to apply the constraints. Returns ------- constraint_result : 2D array of float","Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains","during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem`","equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and","find the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a","an observer # centred frame, so the separation is as-seen # by the","tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals,","length as ``times`` for whether or not the target is ever observable at","test the constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets","targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\"","return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Earth's moon and","shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0]","separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A","observability information for each of the ``targets``. The table contains four columns with","1. , 0.6, 0.2, 0. , 0. ]) \"\"\" rescaled = (vals -","the target (inclusive). `None` indicates no limit. boolean_constraint : bool If True, the","periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\"","and maximum phase must be described on the interval [0, 1). To constrain","targets): \"\"\" Make a unique key to reference this combination of ``times`` and","min is not None else 0.0 self.max = max if max is not","set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None,","b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape","separation between Sun and target (inclusive). `None` indicates no limit. \"\"\" self.min =","raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint):","times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:,","colnames = ['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names","separation in the frame of the moon coord # which is GCRS, and","0.8, 1. ]) \"\"\" rescaled = (vals - min_val) / (max_val - min_val)",": 2D array of float or bool The constraints, with targets along the","aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure","find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt","observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally:","targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return","be passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time,","self.min <= secz elif self.min is not None and self.max is not None:","speedup if the end user # disables gridding and re-shapes the coords themselves","result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually do the real work","plane and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min","`~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer who has","the range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy","'fraction of time observable'] target_names = [target.name for target in targets] ever_obs =","import warnings # Third-party from astropy.time import Time import astropy.units as u from","the Earth's moon and some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\"","within' ' the interval [0, 1).') self.min = min if min is not","import datetime import time import warnings # Third-party from astropy.time import Time import","'times' contains the times for the alt/az computations, (2) 'altaz' contains the corresponding","this class would be to associate an acceptable time range with a specific","is not None: mask = (self.max >= illumination) | moon_down_mask elif self.max is","time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] =","degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as","passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``","times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make","not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``","min_val) / (max_val - min_val) below = vals < min_val above = vals","``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints :",": `~astropy.time.Time` Array of times on which to test the constraint. observer :","ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\"","is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable","from time objects, or from observer if self.min is not None: timezone =","Constraint is also satisfied if the Moon has set. \"\"\" def __init__(self, min=None,","moon_separation elif self.max is None and self.min is not None: mask = self.min","or list of targets. Returns ------- cache_key : tuple A hashable tuple for","the Sun's coordinates in an observer # centred frame, so the separation is","= self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max is","!= np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer,","& moon_up_mask elif self.min is not None and self.max is not None: mask","``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times :","**kwargs): \"\"\" Consider nighttime as time between civil twilights (-6 degrees). \"\"\" return","one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \"\"\" self.min","# Standard library from abc import ABCMeta, abstractmethod import datetime import time import","observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`,","as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes,","{} # convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if","\"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg","observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey]","' the interval [0, 1).') self.min = min if min is not None","max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time","no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon","compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year)","times in some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing","min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz","be specified as \" \"astropy.time.Time objects.\") if self.max is not None: if not","specified as datetime.time objects.\") if self.max is not None: if not isinstance(self.max, datetime.time):","between the Galactic plane and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\"","timezone from time objects, or from observer if self.min is not None: timezone","Examples -------- Constrain the observations to targets that are observable between 23:50 and","illumination for those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} #","<= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\") return","constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to compute","has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional)","(the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not hasattr(constraints,","---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \"\"\" self.eclipsing_system","target (inclusive). `None` indicates no limit. boolean_constraint : bool If True, the constraint","are valid over the time limits used in calls to `is_observable` or `is_always_observable`.","1 what is returned for ``vals`` below ``min_val``. (in some cases anything less","Otherwise, we rely on broadcasting the shapes together using standard numpy rules. Returns","twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider","constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns","---------- times : `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer`","``max_val``. (in some cases anything higher than ``max_val`` should also return one, in","``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational","not None and self.max is not None: mask = ((self.min <= moon_separation) &","return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to","subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the","`None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65,","to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and 1,","def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint =","separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List","the airmass be \"better than 2\", i.e. at a higher altitude than airmass=2::","[constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return","True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints]","no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of","= 0 # find solar altitude at these times altaz = observer.altaz(times, get_sun(times))","given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints :","1, with the best (1) and worst (2.25). All values outside the range","to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on","\"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\"","the values that need to be rescaled to be between 0 and 1","constraints. if targets.isscalar: # ensure we have a (1, 1) shape coord targets","for those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert","targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask","be \"better than 2\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\"","bound times between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50),","MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the Earth's moon. Constraint is also","min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min < 0) or (min >","determine whether ``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list``","about observability for all the ``targets`` over the requested ``time_range``, given the constraints","maximum time.\") if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time","be specified as datetime.time objects.\") if self.max is not None: if not isinstance(self.max,","= min self.max = max if self.min is None and self.max is None:","is NOT the same as targets.separation(moon) # the former calculates the separation in","an array of times for ``targets`` and ``observer``. Cache the result on the","slow due to # complex nature of these objects. We make # to","bounds on time sequence, with spacing ``time_resolution``. This will be passed as the","times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target","self.min <= moon_separation elif self.min is not None and self.max is not None:","if self.min is not None: timezone = self.min.tzinfo elif self.max is not None:","= np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime]) except","min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max","datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone = None # get timezone","some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\"","if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure =","linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable :","observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if","= 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if","'_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing aakey =","cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache =","it returns the Sun's coordinates in an observer # centred frame, so the","in the time range given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints","be between 0 and 1 min_val : float worst acceptable value (rescales to","1 Examples -------- rescale airmasses to between 0 and 1, with the best","has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict",": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target (inclusive).","requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints :","\"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None:","result from # broadcasting times and targets against each other if targets is","24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def","compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <=",">>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units","mask = self.max >= separation elif self.max is None and self.min is not","applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)","not None: mask = (self.max >= illumination) | moon_down_mask elif self.max is None","altitude of the target. .. note:: This can misbehave if you try to","to 1) less_than_min : 0 or 1 what is returned for ``vals`` below","0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses","self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max))","\"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit.","self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function","altitude of the target (inclusive). `None` indicates no limit. boolean_constraint : bool If","if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\"Time limits must","time.\") if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\"Time limits","returned for ``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should","If True, the constraint is treated as a boolean (True for within the","not None: mask = (self.min <= illumination) & moon_up_mask elif self.min is not","and 1, with the best (60) going to 1 and worst (35) going","# TODO: these broadcasting operations are relatively slow # but there is potential","the corresponding alt/az coordinates at those times and (3) contains the moon illumination",">>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50 and 04:08","warnings # Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates","prior to evaluating multiple constraints. if targets.isscalar: # ensure we have a (1,","[constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing","is None else self.max mask = np.logical_and(times > min_time, times < max_time) return","inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and those equal","Array of times on which to test the constraint. observer : `~astroplan.Observer` The","[0, 1). Default is zero. max : float (optional) Maximum phase (inclusive) on","(phase <= self.max), (phase >= self.min) | (phase <= self.max)) return mask def","`~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target (inclusive). `None`","defaults of a minimum of 0.25 and a maximum of 0.65 Parameters ----------","must be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with","time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets`` are always observable throughout","_make_cache_key(times, targets): \"\"\" Make a unique key to reference this combination of ``times``","constraints = [constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times,","is one. Examples -------- To constrain observations on orbital phases between 0.4 and","observable in the time range given the constraints. \"\"\" if not hasattr(constraints, '__len__'):","airmasses to between 0 and 1, with the best (1) and worst (2.25).","be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If","in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints","= np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else:","specified, determine whether constraints are met between test times in ``time_range`` by checking","not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise","limits must be specified as \" \"astropy.time.Time objects.\") if self.max is not None:","from astropy.time import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01","np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab","astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary,","observable at each time, given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints","time import warnings # Third-party from astropy.time import Time import astropy.units as u","is set to 'builtin' by default). \"\"\" self.min = min self.max = max","are met between test times in ``time_range`` by checking constraint at linearly-spaced times","raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times,","``targets`` are observable for a specific ``observer``, given the supplied ``constraints``. Parameters ----------","self.max is not None: mask = ((self.min <= separation) & (separation <= self.max))","'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure","= self.min <= separation elif self.min is not None and self.max is not","that ``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val`` equal","times.shape except BaseException: # must be scalar timekey = (times.jd,) # make hashable","Galactic, SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks import","self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target. In the current","is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) #","shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape =","constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list","constraints are met between test times in ``time_range`` by checking constraint at linearly-spaced","max_val : float best value cared about (rescales to 1) greater_than_max : 0","first index and times along the second. Otherwise, we rely on broadcasting the","Returns ------- constraint_result : 2D array of float or bool The constraints, with","mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint):","is None and self.max is not None: mask = self.max >= solar_separation elif","\"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must","strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a,","of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional)","a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer","`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array of","backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01',","is not None and self.max is not None: mask = ((self.min <= moon_separation)","one, in some cases it should return zero) Returns ------- array of floats","``targets`` and ``times`` in a cache on an ``observer``` object. This routine will","max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates","(times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be","is None.\") else: mx = self.max mi = 1 if self.min is None","if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints","0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination","to one, and the ``max_val`` goes to zero. Parameters ---------- vals : array-like","_get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination for an array","is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets:","applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr","b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def","self.max = max if self.min is None and self.max is None: raise ValueError(\"You","1) less_than_min : 0 or 1 what is returned for ``vals`` below ``min_val``.","`~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None`","assume targets is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,)","observations to times during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ----------","mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine","and 04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints import","for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer,","hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude # attribute","\"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute","`~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range`` is not","real work of computing the constraint. Subclasses override this. Parameters ---------- times :","order matters here # moon.separation(targets) is NOT the same as targets.separation(moon) # the","the end user # disables gridding and re-shapes the coords themselves # prior","will provide an appropriate, hashable, key to store these calculations in a dictionary.","compute the constraint observer : `~astroplan.Observer` the observaton location from which to apply","in an observer # centred frame, so the separation is as-seen # by","use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs.","< 0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint must","in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr","to compute the constraint observer : `~astroplan.Observer` the observaton location from which to","an array of altitudes to be between 0 and 1, with the best","min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which","the times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at","\"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range =","min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates","no limit. min : float or `None` Minimum airmass of the target. `None`","as a scalar. It also contains metadata entries ``'times'`` (with an array of","argument here, which causes small <1 deg # innacuracies, but it is needed","self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`",": `~astroplan.Observer` the observation location from which to apply the constraints targets :","tuple(times.jd) + times.shape except BaseException: # must be scalar timekey = (times.jd,) #","is ever observable at each time, given the constraints. \"\"\" if not hasattr(constraints,","the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or","<= secz) & (secz <= self.max) else: raise ValueError(\"No max and/or min specified","\"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize","mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance","raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target. .. note::","Returns ------- cache_key : tuple A hashable tuple for use as a cache","for each of the ``targets``. The table contains four columns with information about","np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations","import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from","= [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\",","same day: if min_time < max_time: try: mask = np.array([min_time <= t.time() <=","None: mask = self.max >= solar_separation elif self.max is None and self.min is","and self.max is not None: mask = ((self.min <= separation) & (separation <=","BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class","`None` indicates no limit. boolean_constraint : bool If True, the constraint is treated","observable', 'fraction of time observable'] target_names = [target.name for target in targets] ever_obs","that requires the airmass be \"better than 2\", i.e. at a higher altitude","/ (min_val - max_val) below = vals < min_val above = vals >","solar_separation elif self.min is not None and self.max is not None: mask =","constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour):","def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets``","altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr","greater_than_max : 0 or 1 what is returned for ``vals`` above ``max_val``. (in","max def compute_constraint(self, times, observer, targets): # use get_body rather than get sun","times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in","a lot by dropping to the trigonometric # altitude calculations. if not hasattr(constraints,","= observer.timezone if self.min is not None: min_time = self.min else: min_time =","trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times =","array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the","as datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone = None # get","given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by","the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for","(inclusive). `None` indicates no limit. max : float or `None` (optional) Maximum acceptable","times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable at each time in","that ``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val`` equal","\"\"\" rescaled = (vals - max_val) / (min_val - max_val) below = vals","- min_val) below = vals < min_val above = vals > max_val rescaled[below]","numpy arrays of the same shape and # broadcast these to find the","else 0.0 self.max = max if max is not None else 1.0 def","limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples --------","= dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times,","mask = np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase","= None # get timezone from time objects, or from observer if self.min","None: if not isinstance(self.min, Time): raise TypeError(\"Time limits must be specified as \"","PR #5897 is released # which should be astropy 1.3.2 moon = get_moon(times,","if min is not None else 0.0 self.max = max if max is","is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints]","observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey]","1 min_val : float worst acceptable value (rescales to 0) max_val : float","if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure =","None else self.max mask = np.logical_and(times > min_time, times < max_time) return mask","<= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No max and/or min specified","the system could be an eclipsing or non-eclipsing binary, or exoplanet system. min","times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list","get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters here #","min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask =","boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times,","not None and self.max is not None: mask = ((self.min <= solar_separation) &","time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour","\"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year =","Galactic latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or","end user # disables gridding and re-shapes the coords themselves # prior to","# If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time)","import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30, 40,","second. Otherwise, we rely on broadcasting the shapes together using standard numpy rules.","mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No max","zero and one), where the ``min_val`` goes to one, and the ``max_val`` goes","of the same shape and # broadcast these to find the correct shape","def compute_constraint(self, times, observer, targets): \"\"\" Actually do the real work of computing","_get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt","equal 0 and those equal to ``max_val`` equal 1 Examples -------- rescale an","(optional) Lower and upper bounds on time sequence If ``time_range`` is not specified,","'__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for","spacing grid_times_targets : bool if True, grids the constraint result with targets along","``max_val`` goes to zero. Parameters ---------- vals : array-like the values that need","have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets","the airmass of a target. In the current implementation the airmass is approximated","BSD style license - see LICENSE.rst \"\"\" Specify and constraints to determine which",">= solar_separation elif self.max is None and self.min is not None: mask =","array of float or bool The constraints, with targets along the first index","limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and","Constrain observations to times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters",": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional)","case for this class would be to associate an acceptable time range with","separation between Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`","doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \"\"\"","combination of ``targets`` and ``times`` in a cache on an ``observer``` object. This","is not None and self.max is not None: mask = ((self.min <= separation)","targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If","__future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta,","astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy","= min if min is not None else 0.0 self.max = max if","to 1, February maps to 2, etc. \"\"\" # TODO: This method could","'always observable', 'fraction of time observable'] target_names = [target.name for target in targets]","limits must be specified as datetime.time objects.\") if self.max is not None: if","return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache","in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is","range given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints","`~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum of 0.65","the same as targets.separation(moon) # the former calculates the separation in the frame","the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range :","force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between civil twilights","<= solar_separation elif self.min is not None and self.max is not None: mask","return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for objects defining observational constraints.","and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min =","times linearly spaced between the two times in ``time_range`` with grid spacing ``time_resolution``","second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if","needed until astropy PR #5897 is released # which should be astropy 1.3.2","is not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else:",">>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime","minimum of 0.25 and a maximum of 0.65 Parameters ---------- min : float","`~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets","constraint_result : 1D or 2D array of float or bool The constraints. If","altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if","the separation in the frame of the moon coord # which is GCRS,","with the best (1) and worst (2.25). All values outside the range should","who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of","None: mask = ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\"No","[] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in","not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise","or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris","of targets times : `~astropy.time.Time` (optional) Array of times on which to test","released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note","self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else","0 and those equal to ``max_val`` equal 1 Examples -------- rescale an array","<= secz elif self.min is not None and self.max is not None: mask","negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min","for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should also","containing two key-value pairs. (1) 'times' contains the times for the alt/az computations,","transit for an array of times for ``targets`` and ``observer``. Cache the result","max and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain","min_val above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max return","self.min <= solar_separation elif self.min is not None and self.max is not None:","np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets):","datetime.time(0, 0, 0) if self.max is not None: max_time = self.max else: max_time","self.min is None else self.min # values below 1 should be disregarded return","observing block. This can be useful if not all observing blocks are valid","The ``max`` and ``min`` arguments appear in the order (max, min) in this","None: min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0) if","useful if not all observing blocks are valid over the time limits used","To create a constraint that requires the airmass be \"better than 2\", i.e.","float (optional) Minimum phase (inclusive) on interval [0, 1). Default is zero. max","are observable for an observer. \"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals)","observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return","anything less than ``min_val`` should also return one, in some cases it should","meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times","targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times","target. .. note:: This can misbehave if you try to constrain negative altitudes,","zenith angle. .. note:: The ``max`` and ``min`` arguments appear in the order","observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit for","else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target,","Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive).","frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs])","times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey]","Array of times on which to test the constraint time_range : `~astropy.time.Time` (optional)","for a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional)","self.max is None else self.max mask = np.logical_and(times > min_time, times < max_time)","Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is","applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer,","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever","---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it is","min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum","is not None: mask = self.min <= secz elif self.min is not None","given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by","time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import","= observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\"","Constrain the altitude of the target. .. note:: This can misbehave if you",": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None`","and self.max is not None: mask = secz <= self.max elif self.max is","of booleans of same length as ``times`` for whether or not the target","None and self.max is not None: mask = ((self.min <= illumination) & (illumination",": `~numpy.ndarray` Array of booleans of same length as ``times`` for whether or","not None: mask = self.min <= solar_separation elif self.min is not None and","Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max : float or","# innacuracies, but it is needed until astropy PR #5897 is released #","the Sun that can occur when the Sun is below the horizon and","`~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest","to evaluating multiple constraints. if targets.isscalar: # ensure we have a (1, 1)","system could be an eclipsing or non-eclipsing binary, or exoplanet system. min :","a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min","time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target","store expensive calculations for a combination of ``targets`` and ``times`` in a cache","`~astropy.time.Time` Array of times on which to test the constraint observer : `~astroplan.Observer`","be scalar timekey = (times.jd,) # make hashable thing from targets coords try:","``time_range`` is specified, determine whether constraints are met between test times in ``time_range``","times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about observability for all","for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets):","Lower and upper bounds on time sequence If ``time_range`` is not specified, defaults","cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`","a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None):","1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and those","containing a key-value pair. 'times' contains the meridian_transit times. \"\"\" if not hasattr(observer,","``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'``","time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times']","hashable, key to store these calculations in a dictionary. Parameters ---------- times :","or not each target is ever observable in the time range given the","which must be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times,","solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in","max and/or min specified in \" \"AirmassConstraint.\") return mask else: if self.max is","or `None` (optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates","observer # centred frame, so the separation is as-seen # by the observer.","& (phase <= self.max), (phase >= self.min) | (phase <= self.max)) return mask","the ``target`` is observable at each time in ``times``, given constraints in ``constraints``","requires the airmass be \"better than 2\", i.e. at a higher altitude than","appropriate, hashable, key to store these calculations in a dictionary. Parameters ---------- times","observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to","astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5,","Lower and upper bounds on time sequence, with spacing ``time_resolution``. This will be","\"\"\" Constrain the distance between the Sun and some targets. \"\"\" def __init__(self,","times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint:","[constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints]","and times along the second. \"\"\" # Should be implemented on each subclass","observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >=","self.min is not None and self.max is not None: mask = ((self.min <=","hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar:","Cache the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array","constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always","def compute_constraint(self, times, observer, targets): timezone = None # get timezone from time","> max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val,","as time between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def","order (max, min) in this initializer to support the common case for users",": `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system","is needed until astropy PR #5897 is released # which should be astropy","\"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the Earth's","correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x,","Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets","astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\")","with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time","**kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and","0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint","else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz","a score (between zero and one), where the ``max_val`` goes to one, and","index and times along the second. Otherwise, we rely on broadcasting the shapes","compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if","for outside). If False, the constraint returns a float on [0, 1], where","values that need to be rescaled to be between 0 and 1 min_val","the former calculates the separation in the frame of the moon coord #","should return 0 below 35 and 1 above 60. >>> from astroplan.constraints import","defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,","datetime.time objects.\") if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time","is the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None:","constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\"","mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during","pairs. (1) 'times' contains the times for the computations, (2) 'altaz' contains the","0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1)","<= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within","for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable',","np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target``","phase (inclusive) on interval [0, 1). Default is zero. max : float (optional)","be between 0 and 1, with the best (60) going to 1 and","bool if True, grids the constraint result with targets along the first index",", 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled = (vals - min_val) /","target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable at each time","than 2\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self,","`~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array of times","1). Default is zero. max : float (optional) Maximum phase (inclusive) on interval","= [constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True)","WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2)","in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz =","None: timezone = observer.timezone if self.min is not None: min_time = self.min else:","mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below ``horizon``.","Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`","the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table =",": list List of sets of unique integers representing each month that a","self.max)) & moon_up_mask else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\")","and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time >>>","between 0.6 and 1.2, for example, you should subtract one from the second","targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure","is None and self.min is not None: mask = self.min <= solar_separation elif","on which to apply the constraints. times : `~astropy.time.Time` The times to compute","and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets =","airmass of the target. `None` indicates no limit. boolean_contstraint : bool Examples --------","what we want. moon_separation = moon.separation(targets) if self.min is None and self.max is","of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence","to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for","(optional) Array of mid-event times on which to test the constraints times_ingress_egress :","at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True):","`~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for a 24","is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint","limit. max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None`","the zenith angle. .. note:: The ``max`` and ``min`` arguments appear in the","illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure =","[constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr,","= boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt","\"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple","class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target. .. note:: This can","This can misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz`","with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of","given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times","as datetime.time objects.\") if self.max is not None: if not isinstance(self.max, datetime.time): raise","eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint):","to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache:","cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask","astropy.time import Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon,","Constrain the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True):","not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified as","max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within certain","of the zenith angle. .. note:: The ``max`` and ``min`` arguments appear in","if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint","<= self.max) else: raise ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\") return","``targets``. Often, we wish to store expensive calculations for a combination of ``targets``","if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max return","tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1):","(optional) Maximum phase (inclusive) on interval [0, 1). Default is one. Examples --------","each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of","blocks are valid over the time limits used in calls to `is_observable` or","hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True)","or `None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint :","class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary eclipse. \"\"\" def __init__(self,","_make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure","# complex nature of these objects. We make # to simple numpy arrays","min_time = self.min = datetime.time(0, 0, 0) if self.max is not None: max_time","0.6, 0.2, 0. , 0. ]) \"\"\" rescaled = (vals - max_val) /","self.min is None and self.max is None: raise ValueError(\"You must at least supply","try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination","constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list,","ever_observable : list List of booleans of same length as ``targets`` for whether","class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target. In the current implementation","import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\"AltitudeConstraint\",","rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an","be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors -","times for ``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters","\"\"\" # TODO: This method could be sped up a lot by dropping","self.max is not None: timezone = self.max.tzinfo if timezone is None: timezone =","`None` indicates no limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates","t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <=","of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] =","np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually do","calculations. This avoids errors in the altitude of the Sun that can occur","# first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt","max=None, ephemeris=None): \"\"\" Parameters ---------- min : float or `None` (optional) Minimum acceptable","targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the","object. Accessing the longitude # attribute of the frame data should be unique","observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask","and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as","expensive calculations for a combination of ``targets`` and ``times`` in a cache on","altitude and 1 is the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if","if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar')",">>> import datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound","the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times on which","self.max)) else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask","with targets along the first index and times along the second. \"\"\" #","raise ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint):","# disables gridding and re-shapes the coords themselves # prior to evaluating multiple","above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max return rescaled","class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\"","given as a scalar. It also contains metadata entries ``'times'`` (with an array","(-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not","if the ``target`` is observable at each time in ``times``, given constraints in","= abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask =","0) max_val : float best value cared about (rescales to 1) greater_than_max :","& uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass","_make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure","ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is","min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates",">>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max","= Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask = np.logical_and(times > min_time,","list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints","import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1","This can be useful if not all observing blocks are valid over the","None and self.max is not None: mask = (self.max >= illumination) | moon_down_mask","in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range,","a scalar. It also contains metadata entries ``'times'`` (with an array of all","if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] =","score (between zero and one), where the ``min_val`` goes to one, and the","'builtin' by default). \"\"\" self.min = min self.max = max self.ephemeris = ephemeris","potential for huge speedup if the end user # disables gridding and re-shapes","= max if self.min is None and self.max is None: raise ValueError(\"You must","can misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame","determine whether constraints are met between test times in ``time_range`` by checking constraint","``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List of sets","or not each target is observable in the time range given the constraints.","# bound times between 23:50 and 04:08 local Hawaiian time >>> constraint =","a cache key \"\"\" # make a tuple from times try: timekey =","= boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz","Minimum acceptable separation between Sun and target (inclusive). `None` indicates no limit. max","Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord","maximum of 0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable","np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer,","between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\"","the ``targets``. The table contains four columns with information about the target and","target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs =","def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude","should return zero) Returns ------- array of floats between 0 and 1 inclusive","and upper bounds on time sequence If ``time_range`` is not specified, defaults to","moon_separation = moon.separation(targets) if self.min is None and self.max is not None: mask","None and self.min is not None: mask = (self.min <= illumination) & moon_up_mask","<= self.max), (phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints,","goes to one, and the ``max_val`` goes to zero. Parameters ---------- vals :","0 and 1 min_val : float worst acceptable value (rescales to 0) max_val","atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod","return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>>","\"\"\" Determines if the ``target`` is observable at each time in ``times``, given","Sun that can occur when the Sun is below the horizon and the","float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit.","altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure","If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to","axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab =","_get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times linearly spaced","(vals - min_val) / (max_val - min_val) below = vals < min_val above","``'fraction of time observable'``. The column ``'time observable'`` will also be present if","targets) # make sure the output has the same shape as would result","55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0.","None: mask = self.max >= separation elif self.max is None and self.min is","unique integers representing each month that a target is observable, one set per","def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination for an","# values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class","between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs):","1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest:","at those times and (3) contains the moon illumination for those times. \"\"\"","---------- max : float or `None` Maximum airmass of the target. `None` indicates","create a constraint that requires the airmass be \"better than 2\", i.e. at","None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask","\"\"\" Constrain observations to times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\"","shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) #","and re-shapes the coords themselves # prior to evaluating multiple constraints. if targets.isscalar:","& moon_up_mask else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return","times for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times","second. \"\"\" if times is None and time_range is not None: times =","v targets is slow due to # complex nature of these objects. We","times.datetime]) except BaseException: # use np.bool so shape queries don't cause problems mask","between test times in ``time_range`` by checking constraint at linearly-spaced times separated by","<= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return","1. ]) \"\"\" rescaled = (vals - min_val) / (max_val - min_val) below","1D or 2D array of float or bool The constraints. If 2D with","isinstance(self.max, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") def","no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs):","no limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): #","approximated by the secant of the zenith angle. .. note:: The ``max`` and","of times on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower","= Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31']","set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \"\"\" self.min =","min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None`","`None` indicates no limit. max : float or `None` (optional) Maximum acceptable fractional","mi = 1 if self.min is None else self.min # values below 1","a 3-clause BSD style license - see LICENSE.rst \"\"\" Specify and constraints to","import ABCMeta, abstractmethod import datetime import time import warnings # Third-party from astropy.time","limit. min : float or `None` Minimum airmass of the target. `None` indicates","the times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates","max_val) below = vals < min_val above = vals > max_val rescaled[below] =","= [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr,","of times on which to test the constraint. observer : `~astroplan.Observer` The observer","+ targets.shape else: # assume targets is a string. targkey = (targets,) except","we rely on broadcasting the shapes together using standard numpy rules. Returns -------","`~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target (inclusive). `None`","1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False)","as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50","\"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range","force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon","or `None` (optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates","TypeError(\"Time limits must be specified as datetime.time objects.\") def compute_constraint(self, times, observer, targets):","Target or list of targets. Returns ------- cache_key : tuple A hashable tuple","so that ``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val``","Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains","maximum of 0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable","None: raise ValueError(\"You must at least supply either a minimum or a \"","array ``vals`` to be a score (between zero and one), where the ``max_val``","constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key :","Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask = np.logical_and(times > min_time, times","constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None):","initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum","eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint):","0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure:","the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,","targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames","``max_val`` should also return one, in some cases it should return zero) Returns","limit. Examples -------- Constrain the observations to targets that are observable between 2016-03-28","a maximum of 0.25 Parameters ---------- min : float or `None` (optional) Minimum","class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic plane and some targets.","ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\"","timezone = observer.timezone if self.min is not None: min_time = self.min else: min_time","ingress and egress times for ``N`` events, with shape (``N``, 2). Returns -------","to be between 0 and 1 min_val : float worst acceptable value (rescales","observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude =","but there is potential for huge speedup if the end user # disables","aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0","make # to simple numpy arrays of the same shape and # broadcast","spaced between the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``.","the airmass is approximated by the secant of the zenith angle. .. note::","a maximum of 0.65 Parameters ---------- min : float or `None` (optional) Minimum","mask = self.min <= separation elif self.min is not None and self.max is","self.min = datetime.time(0, 0, 0) if self.max is not None: max_time = self.max","as np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from","on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress","(min_val - max_val) below = vals < min_val above = vals > max_val","------- ever_observable : list List of booleans of same length as ``targets`` for","in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask","returned for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should","indicates no limit. \"\"\" self.min = min self.max = max def compute_constraint(self, times,","max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4,","import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day)","max : float (optional) Maximum phase (inclusive) on interval [0, 1). Default is","below the horizon and the corrections for atmospheric refraction return nonsense values. \"\"\"","the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to","= observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] =","class for objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer,","the Moon has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ----------","max_time: try: mask = np.array([min_time <= t.time() <= max_time for t in times.datetime])","is observable, one set per target. These integers are 1-based so that January","if self.max is None: raise ValueError(\"Cannot have a float AirmassConstraint if max is","targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times)","Make a unique key to reference this combination of ``times`` and ``targets``. Often,","---------- min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None`","be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings():","self.max mask = np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint):","and/or min specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the","if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude #","a minimum or a maximum time.\") if self.min is not None: if not","<= separation) & (separation <= self.max)) else: raise ValueError(\"No max and/or min specified","convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey","a target is observable, one set per target. These integers are 1-based so","np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) #","the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint","(rescales to 1) greater_than_max : 0 or 1 what is returned for ``vals``","zero for solar altitude calculations. This avoids errors in the altitude of the","to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of","``observer``. Cache the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time`","not None: mask = ((self.min <= separation) & (separation <= self.max)) else: raise","specific observing block. This can be useful if not all observing blocks are","Earth's moon and some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters","targets times : `~astropy.time.Time` (optional) Array of times on which to test the","# prior to evaluating multiple constraints. if targets.isscalar: # ensure we have a","minimum of the PhaseConstraint must be within' ' the interval [0, 1).') self.min","along the first index and times along the second. Otherwise, we rely on","if not all observing blocks are valid over the time limits used in","`~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper","\" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Earth's","\"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which",">>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru =","``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range :",">>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be","* len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape","is None: self.min = -90*u.deg else: self.min = min if max is None:","altitude of the Sun that can occur when the Sun is below the","hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat as a","that need to be rescaled to be between 0 and 1 min_val :","use as a cache key \"\"\" # make a tuple from times try:","hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for hashing","\"\"\" Constrain the altitude of the target. .. note:: This can misbehave if","\"better than 2\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def","by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours.","be present if the ``time_range`` is given as a scalar. It also contains","target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use.","__init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum","Earth's moon. Constraint is also satisfied if the Moon has set. \"\"\" def","(inclusive). `None` indicates no limit. \"\"\" self.min = min self.max = max def","the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will","information about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``,","times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in","for t in times.datetime]) except BaseException: # use np.bool so shape queries don't","and self.min is not None: mask = self.min <= moon_separation elif self.min is","hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints =","is None and self.max is not None: mask = self.max >= separation elif","= np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure","\"\"\" Constrain the fractional illumination of the Earth's moon. Constraint is also satisfied","or (max < 0) or (max > 1): raise ValueError('The minimum of the","for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list","observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully","constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and","cache on an ``observer``` object. This routine will provide an appropriate, hashable, key","compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain","self.max >= solar_separation elif self.max is None and self.min is not None: mask","non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase (inclusive) on","= force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between civil","Maximum acceptable separation between moon and target (inclusive). `None` indicates no limit. ephemeris","The targets on which to apply the constraints. times : `~astropy.time.Time` The times","cases anything higher than ``max_val`` should also return one, in some cases it","limit. \"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\"","key to reference this combination of ``times`` and ``targets``. Often, we wish to","an appropriate, hashable, key to store these calculations in a dictionary. Parameters ----------","get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as np","a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey +","the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min","= [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target,","Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") if self.max","in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\"","time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets`` are observable for a specific","are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from","for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times =","# cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure =","2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time >>> subaru","< 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is","binary, or exoplanet system. min : float (optional) Minimum phase (inclusive) on interval","to be a score (between zero and one), where the ``max_val`` goes to","unique key to reference this combination of ``times`` and ``targets``. Often, we wish","hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure:","is None and self.min is not None: mask = self.min <= secz elif","Sun is below the horizon and the corrections for atmospheric refraction return nonsense","for huge speedup if the end user # disables gridding and re-shapes the","of 0.65 and no maximum Parameters ---------- min : float or `None` (optional)","either a minimum or a \" \"maximum time.\") if self.min is not None:","(in some cases anything higher than ``max_val`` should also return one, in some","return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input array ``vals``","throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ----------","the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a particular","class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun and some targets. \"\"\"","as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time","one, and the ``max_val`` goes to zero. Parameters ---------- vals : array-like the","target (inclusive). `None` indicates no limit. \"\"\" self.min = min self.max = max","constraint that requires the airmass be \"better than 2\", i.e. at a higher","\"\"\" Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination","calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on","times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for","[target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1)","altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets):","is the min altitude and 1 is the max. \"\"\" def __init__(self, min=None,","a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum of","table contains four columns with information about the target and it's observability: ``'target","targets): # use get_body rather than get sun here, since # it returns","and constraints to determine which targets are observable for an observer. \"\"\" from","(inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use. If","self.max = max if max is not None else 1.0 def compute_constraint(self, times,","0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input array","astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u","it is considered to be \"night\" (inclusive). force_pressure_zero : bool (optional) Force the","in a cache on an ``observer``` object. This routine will provide an appropriate,","Sun and target (inclusive). `None` indicates no limit. \"\"\" self.min = min self.max","to determine whether ``targets`` are always observable throughout ``time_range`` given constraints in the","the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\"","objects.\") def compute_constraint(self, times, observer, targets): timezone = None # get timezone from","\"\"\" Determines which month the specified ``targets`` are observable for a specific ``observer``,","= {} # convert times, targets to tuple for hashing aakey = _make_cache_key(times,","to targets that are observable between 23:50 and 04:08 local time: >>> from","return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain",": float or `None` Maximum airmass of the target. `None` indicates no limit.","Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target. ..","not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") if","are observable for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints","print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime import","of `~astroplan.Target` The targets on which to apply the constraints. times : `~astropy.time.Time`","same shape as would result from # broadcasting times and targets against each","/ constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None","calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr =","times v targets is slow due to # complex nature of these objects.","times, observer, targets): # first is the moon up? cached_moon = _get_moon_data(times, observer)","constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction","`~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND","= np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if",": bool (optional) Force the pressure to zero for solar altitude calculations. This","rescale airmasses to between 0 and 1, with the best (1) and worst","best (60) going to 1 and worst (35) going to 0. For values","times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is not","\" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the","= observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit","24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``","1 if self.min is None else self.min # values below 1 should be","latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`","set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \"\"\" self.min =","WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length","is None: raise ValueError(\"Cannot have a float AirmassConstraint if max is None.\") else:","dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for objects defining observational","set to 'builtin' by default). \"\"\" self.min = min self.max = max self.ephemeris","is as-seen # by the observer. # 'get_sun' returns ICRS coords. sun =","\"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to","= ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument here,","Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min","def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min","observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable during",": `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the observaton","dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \"\"\" if","to be \"night\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero","target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum","= times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True)","1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np","acceptable separation between Sun and target (inclusive). `None` indicates no limit. \"\"\" self.min","specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours.","observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will","which month the specified ``targets`` are observable for a specific ``observer``, given the","minimum and a maximum of 0.25 Parameters ---------- min : float or `None`","ephemeris=None): \"\"\" Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional","Maximum phase (inclusive) on interval [0, 1). Default is one. Examples -------- To","`~astropy.time.Time` Array of times on which to test the constraint. targets : {list,","times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in","to # complex nature of these objects. We make # to simple numpy","former calculates the separation in the frame of the moon coord # which","outside the range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import","float best value cared about (rescales to 1) greater_than_max : 0 or 1","= np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException: #","as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import","these broadcasting operations are relatively slow # but there is potential for huge","in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or","observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination for","of mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional)","same length as ``targets`` for whether or not each target is ever observable","`None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the","\"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or","objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None,","scalar. It also contains metadata entries ``'times'`` (with an array of all the","local time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>>","computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times. \"\"\" if","limit. boolean_contstraint : bool Examples -------- To create a constraint that requires the","least supply either a minimum or a \" \"maximum time.\") if self.min is","which must be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times,","= observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure =","the airmass (``max``) and not the lower limit. Parameters ---------- max : float","< min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0","on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper","a lot by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer,","less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg)","---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and","not None: if not isinstance(self.max, Time): raise TypeError(\"Time limits must be specified as","The column ``'time observable'`` will also be present if the ``time_range`` is given","``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \"\"\" self.min = min self.max","get sun here, since # it returns the Sun's coordinates in an observer","for ``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should also","observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar","class Constraint(object): \"\"\" Abstract class for objects defining observational constraints. \"\"\" __metaclass__ =","no maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional","str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a unique key to","Array of booleans of same length as ``times`` for whether or not the","range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as","return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be","if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to","boolean (True for within the limits and False for outside). If False, the","with defaults of a minimum of 0.25 and a maximum of 0.65 Parameters","the constraints targets : sequence of `~astroplan.Target` The targets on which to apply","of the sun below which it is considered to be \"night\" (inclusive). force_pressure_zero","observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun')","min : float (optional) Minimum phase (inclusive) on interval [0, 1). Default is","that a target is observable, one set per target. These integers are 1-based","\"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple","moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates the separation","moon coord # which is GCRS, and that is what we want. moon_separation","((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No max and/or min","force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times linearly spaced between the two","<= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic","time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint","present if the ``time_range`` is given as a scalar. It also contains metadata","``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and","tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey = (targets,)","moon_up_mask elif self.min is not None and self.max is not None: mask =","should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors","time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets`` are always observable throughout ``time_range``","dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints =","target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s)","treat as a SkyCoord object. Accessing the longitude # attribute of the frame","to 1 and worst (35) going to 0. For values outside the range,","---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and","constraints to determine which targets are observable for an observer. \"\"\" from __future__","try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude","force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination for an array of times","to apply the constraints. times : `~astropy.time.Time` The times to compute the constraint.","the observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min :","Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length as ``times``","no limit. boolean_contstraint : bool Examples -------- To create a constraint that requires","& (solar_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \"","by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table","here # moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates","on orbital phases between 0.6 and 1.2, for example, you should subtract one","# Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates import","# use np.bool so shape queries don't cause problems mask = np.bool_(min_time <=","as ``targets`` for whether or not each target is ever observable in the","Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \"\"\" if not","to store expensive calculations for a combination of ``targets`` and ``times`` in a","raise ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\") return mask else: if","observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets)","not None: max_time = self.max else: max_time = datetime.time(23, 59, 59) # If","= np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2,","solar_separation = sun.separation(targets) if self.min is None and self.max is not None: mask","default). \"\"\" self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self,","constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation location from","(between zero and one), where the ``min_val`` goes to one, and the ``max_val``","constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer :","described on the interval [0, 1). To constrain observations on orbital phases between","float on [0, 1], where 0 is the min altitude and 1 is","from .moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__","for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs","times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on","<= separation elif self.min is not None and self.max is not None: mask","the distance between the Earth's moon and some targets. \"\"\" def __init__(self, min=None,","not None else 0.0 self.max = max if max is not None else","None: mask = self.min <= secz elif self.min is not None and self.max","at least supply either a minimum or a maximum time.\") if self.min is","0.5 hours. Returns ------- ever_observable : list List of booleans of same length","than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume","is approximated by the secant of the zenith angle. .. note:: The ``max``","`None` indicates no limit. ephemeris : str, optional Ephemeris to use. If not","minimum or a \" \"maximum time.\") if self.min is not None: if not","observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max","horizon and the corrections for atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude =","input array ``vals`` to be a score (between zero and one), where the","below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import","eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary","is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask =","the constraint returns a float on [0, 1], where 0 is the min","January maps to 1, February maps to 2, etc. \"\"\" # TODO: This","aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure","and self.max is not None: mask = (self.max >= illumination) | moon_down_mask elif","exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event","list of targets times : `~astropy.time.Time` (optional) Array of times on which to","or 1 what is returned for ``vals`` above ``max_val``. (in some cases anything","target. These integers are 1-based so that January maps to 1, February maps",">= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing","Constrain the distance between the Galactic plane and some targets. \"\"\" def __init__(self,","the observations to targets that are observable between 2016-03-28 and 2016-03-30: >>> from","not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified as","not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO:","from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\",","(rescales to 1) less_than_min : 0 or 1 what is returned for ``vals``","to reference this combination of ``times`` and ``targets``. Often, we wish to store","time_dict : dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times.","limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None`","must be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None,","specified in \" \"AirmassConstraint.\") return mask else: if self.max is None: raise ValueError(\"Cannot","constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range =","initializer to support the common case for users who care about the upper","from astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided #","the longitude # attribute of the frame data should be unique and is","(inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for solar altitude","is not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else:","for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if","the observing time to be within certain time limits. An example use case","those equal to ``max_val`` equal 1 Examples -------- rescale an array of altitudes","(max < 0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint",": `~astroplan.Observer` the observaton location from which to apply the constraints targets :","max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the moon up?","not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not","and 1 is the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min","2D with targets along the first index and times along the second. \"\"\"","observer. \"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from","the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum","and illumination for an array of times for ``observer``. Cache the result on","dict Dictionary containing three key-value pairs. (1) 'times' contains the times for the","airmass is approximated by the secant of the zenith angle. .. note:: The","and ``'fraction of time observable'``. The column ``'time observable'`` will also be present","---------- vals : array-like the values that need to be rescaled to be","boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt =","max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25","Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max =","altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask =","target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To create a","example, you should subtract one from the second number: >>> constraint = PhaseConstraint(binary,","on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True,","(optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates no limit.","time objects, or from observer if self.min is not None: timezone = self.min.tzinfo","constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be described","not each target is ever observable in the time range given the constraints.","to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints]","np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min)","['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name","45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. ,","\"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest local","PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary eclipse. \"\"\" def __init__(self, eclipsing_system):","hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing aakey",": dict Dictionary containing three key-value pairs. (1) 'times' contains the times for","datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") if self.max is","MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Earth's moon and some targets. \"\"\"","at least supply either a minimum or a \" \"maximum time.\") if self.min","time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to targets",": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional)","targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = []","not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod","rescaled so that ``vals`` equal to ``max_val`` equal 0 and those equal to","targets along the first index and times along the second. Otherwise, we rely","def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times linearly","observer.pressure = 0 # find solar altitude at these times altaz = observer.altaz(times,","(separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\")","self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is not None:","constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of","and those equal to ``max_val`` equal 1 Examples -------- rescale an array of","time.\") if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits","(-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target,","array of times for ``observer``. Cache the result on the ``observer`` object. Parameters","observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] =","must be within' ' the interval [0, 1).') self.min = min if min","would be to associate an acceptable time range with a specific observing block.","on [0, 1], where 0 is the min altitude and 1 is the","(max_val - min_val) below = vals < min_val above = vals > max_val","constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list,","target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs =","np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if","elif self.min is not None and self.max is not None: mask = ((self.min","altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times,","times on which to test the constraint observer : `~astroplan.Observer` The observer who","not None: min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0)","observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try:","Examples -------- To constrain observations on orbital phases between 0.4 and 0.6, >>>","the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`","constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array","If a single (scalar) time, the table will be for a 24 hour","\"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'):","2D array of float or bool The constraints, with targets along the first","else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class","\"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint","if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must","elif self.max is None and self.min is not None: mask = self.min <=","distance between the Sun and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\"","fractional illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod","`~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def","observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation =","same length as ``targets`` for whether or not each target is observable in","next meridian transit for an array of times for ``targets`` and ``observer``. Cache","None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time","not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and","max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input array ``vals`` to be a","event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters","result with targets along the first index and times along the second. Otherwise,","those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0","targets.separation(moon) # the former calculates the separation in the frame of the moon","PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u >>> binary","is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability","AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target. .. note:: This can misbehave","warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time =","secz elif self.min is not None and self.max is not None: mask =","mask else: if self.max is None: raise ValueError(\"Cannot have a float AirmassConstraint if","be a score (between zero and one), where the ``min_val`` goes to one,","targets on which to apply the constraints. Returns ------- constraint_result : 2D array","__all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\",","sets of unique integers representing each month that a target is observable, one","Determines if the ``target`` is observable at each time in ``times``, given constraints","ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint","observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and","array of floats between 0 and 1 inclusive rescaled so that ``vals`` equal","0 and 1, with the best (60) going to 1 and worst (35)","mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def __init__(self, min=None, max=None):","\"maximum time.\") if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\"Time","= max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize","not None: mask = self.max >= solar_separation elif self.max is None and self.min","times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr,","``targets``. The table contains four columns with information about the target and it's","observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The","np.bool so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <=","or subclass System on which to compute the phase. For example, the system","best (1) and worst (2.25). All values outside the range should return 0.","targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this class Parameters","in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable',","targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure","disables gridding and re-shapes the coords themselves # prior to evaluating multiple constraints.","times and targets against each other if targets is not None: # broadcasting","objects. We make # to simple numpy arrays of the same shape and","compute_constraint(self, times, observer, targets): # use get_body rather than get sun here, since","constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min < 0)","None: mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else:","altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min :","at those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert","# get timezone from time objects, or from observer if self.min is not","A function to determine whether ``targets`` are always observable throughout ``time_range`` given constraints","Package from .moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord","using standard numpy rules. Returns ------- constraint_result : 1D or 2D array of","observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure","and some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min","= get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters here","# altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range,","2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP","hours. Returns ------- observable_months : list List of sets of unique integers representing","= np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s =","fractional illumination (inclusive). `None` indicates no limit. max : float or `None` (optional)","and ``min`` arguments appear in the order (max, min) in this initializer to",": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict :","2, etc. \"\"\" # TODO: This method could be sped up a lot",": `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``.","#5897 is released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris)","self.min = min self.max = max def compute_constraint(self, times, observer, targets): separation =","Returns ------- observable_months : list List of sets of unique integers representing each","sped up a lot by dropping to the trigonometric # altitude calculations. applied_constraints","2D array of float or bool The constraints. If 2D with targets along","__init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in","constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr):","three key-value pairs. (1) 'times' contains the times for the computations, (2) 'altaz'","List of booleans of same length as ``targets`` for whether or not each","the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of","moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum']","`~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met between test",": dict Dictionary containing two key-value pairs. (1) 'times' contains the times for","min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): #","Force the pressure to zero for solar altitude calculations. This avoids errors in","---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target","_get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt","and/or min specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the","output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return","or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max","time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing","be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None):",", 0. , 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled = (vals -","max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic","periodic_event if (min < 0) or (min > 1) or (max < 0)","targets): # first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt =","Determines which month the specified ``targets`` are observable for a specific ``observer``, given","+ '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a unique","times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at","to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ----------","elif self.max is None and self.min is not None: mask = (self.min <=","time between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times,","up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0","to times in some range of phases for a periodic event (e.g.~transiting exoplanets,","times is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if","min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive).","the PhaseConstraint must be within' ' the interval [0, 1).') self.min = min","for an array of times for ``targets`` and ``observer``. Cache the result on","initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25","import datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times","Array of times on which to test the constraint observer : `~astroplan.Observer` The","if self.min is None and self.max is not None: mask = self.max >=","with defaults of no minimum and a maximum of 0.25 Parameters ---------- min","observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ----------","between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer,","np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod","mask = self.max >= solar_separation elif self.max is None and self.min is not","SkyCoord object. Accessing the longitude # attribute of the frame data should be","from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as","= (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times,","backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\"","phase must be described on the interval [0, 1). To constrain observations on","for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time()","def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a","self.boolean_constraint: if self.min is None and self.max is not None: mask = secz","of unique integers representing each month that a target is observable, one set","None.\") else: mx = self.max mi = 1 if self.min is None else","for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None,","def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between astronomical twilights (-18 degrees).","higher than ``max_val`` should also return one, in some cases it should return","1 is the max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is","target. In the current implementation the airmass is approximated by the secant of","all observing blocks are valid over the time limits used in calls to","hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is",">= 0 illumination = cached_moon['illum'] if self.min is None and self.max is not","times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames =","from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\"Subaru\",","between 0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal","SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets,","equal to ``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples","= observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az","For values outside the range, the rescale should return 0 below 35 and","and the corrections for atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude","apply the constraints targets : sequence of `~astroplan.Target` The targets on which to","cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not None: mask","self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument","would result from # broadcasting times and targets against each other if targets","`is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest","`~astropy.time.Time` Array of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord`","(min < 0) or (min > 1) or (max < 0) or (max","acceptable separation between moon and target (inclusive). `None` indicates no limit. max :","or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on","= sun.separation(targets) if self.min is None and self.max is not None: mask =","is not None: mask = self.max >= moon_separation elif self.max is None and","times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint:","minimum or a maximum time.\") if self.min is not None: if not isinstance(self.min,",": `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met between","to be rescaled to be between 0 and 1 min_val : float worst","each other if targets is not None: # broadcasting times v targets is","(True for within the limits and False for outside). If False, the constraint","else: raise ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\") return mask class","not isinstance(self.min, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\")","the lower limit. Parameters ---------- max : float or `None` Maximum airmass of","0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0","illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer,","self.min is not None and self.max is not None: mask = (self.min <=","if self.min is None and self.max is not None: mask = (self.max >=","]) \"\"\" rescaled = (vals - max_val) / (min_val - max_val) below =","Constraint(object): \"\"\" Abstract class for objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta","min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time","``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and 1, with","max if self.min is None and self.max is None: raise ValueError(\"You must at","grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters","if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination =","from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1,","\"\"\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize","observer if self.min is not None: timezone = self.min.tzinfo elif self.max is not","the constraint is treated as a boolean (True for within the limits and","times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system :","If 2D with targets along the first index and times along the second.","``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a","min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable","values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint):","calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) #","mask = self.max >= moon_separation elif self.max is None and self.min is not","by default). \"\"\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod","in times.datetime]) except BaseException: # use np.bool so shape queries don't cause problems","None: mask = (self.min <= illumination) & moon_up_mask elif self.min is not None","aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0","have a float AirmassConstraint if max is None.\") else: mx = self.max mi","if True, grids the constraint result with targets along the first index and","current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether","Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local","is None and self.min is not None: mask = self.min <= separation elif","result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times","not None: mask = (self.min <= secz) & (secz <= self.max) else: raise","ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument here, which","self.max) else: raise ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\") return mask","observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`,","less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. ,","`~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None`","target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude","from targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object.","__init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional)","# doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ])","targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times","integers representing each month that a target is observable, one set per target.","not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin'","`None` Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint :","= [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr =","``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will also","moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters","moon illumination for those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {}","times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for","time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range``","an input array ``vals`` to be a score (between zero and one), where","(targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer,","self.max is None and self.min is not None: mask = self.min <= secz","moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and","for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]])","for this class would be to associate an acceptable time range with a","airmass of a target. In the current implementation the airmass is approximated by","by default). \"\"\" self.min = min self.max = max self.ephemeris = ephemeris def","float best value cared about (rescales to 1) less_than_min : 0 or 1","'_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache:","\"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\",","moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`","goes to zero. Parameters ---------- vals : array-like the values that need to","is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def","mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some range of phases","to zero. Parameters ---------- vals : array-like the values that need to be","months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a","limit. \"\"\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\"","force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary","mask = self.min <= secz elif self.min is not None and self.max is","@classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of","timezone=\"US/Hawaii\") >>> # bound times between 23:50 and 04:08 local Hawaiian time >>>","< 0) or (min > 1) or (max < 0) or (max >","outside). If False, the constraint returns a float on [0, 1], where 0","in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None,","by dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints","support the common case for users who care about the upper limit on","note:: This can misbehave if you try to constrain negative altitudes, as the","observations to times in some range of phases for a periodic event (e.g.~transiting","max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun","object. Parameters ---------- times : `~astropy.time.Time` Array of times on which to test","``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples -------- rescale","to find the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1])","LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max = max if self.min is None","secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System","max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates",": `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system","`~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0","or `None` Maximum airmass of the target. `None` indicates no limit. min :","get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but there is","sequence of `~astroplan.Target` The targets on which to apply the constraints. times :","max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min = min","Actually do the real work of computing the constraint. Subclasses override this. Parameters","targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if","so the separation is as-seen # by the observer. # 'get_sun' returns ICRS","between Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or","same as targets.separation(moon) # the former calculates the separation in the frame of","in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`","or 2D array of float or bool The constraints. If 2D with targets","`~numpy.ndarray` Array of booleans of same length as ``times`` for whether or not","observable for an observer. \"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals) #","``times`` and ``targets``. Often, we wish to store expensive calculations for a combination","we wish to store expensive calculations for a combination of ``targets`` and ``times``","Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50 and 04:08 local Hawaiian time","targets against each other if targets is not None: # broadcasting times v","tuple A hashable tuple for use as a cache key \"\"\" # make","targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity`","pair. 'times' contains the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache =","on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude","observer, targets): # use get_body rather than get sun here, since # it","---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max","and not the lower limit. Parameters ---------- max : float or `None` Maximum",">>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\"","during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints","here, since # it returns the Sun's coordinates in an observer # centred","= (self.min <= secz) & (secz <= self.max) else: raise ValueError(\"No max and/or","(self.max >= illumination) | moon_down_mask elif self.max is None and self.min is not","so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time)","mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime])","0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information","self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None,","> 1): raise ValueError('The minimum of the PhaseConstraint must be within' ' the","negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target","fractional illumination of the Earth's moon. Constraint is also satisfied if the Moon","to 2, etc. \"\"\" # TODO: This method could be sped up a","one. Examples -------- To constrain observations on orbital phases between 0.4 and 0.6,","is not None: max_time = self.max else: max_time = datetime.time(23, 59, 59) #",">>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint","`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer who","> self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min) |","is returned for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val``","indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65,","Returns ------- ever_observable : list List of booleans of same length as ``targets``","booleans of same length as ``times`` for whether or not the target is","``target`` at times linearly spaced between the two times in ``time_range`` with grid","if timezone is None: timezone = observer.timezone if self.min is not None: min_time",": `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}","raise ValueError(\"Cannot have a float AirmassConstraint if max is None.\") else: mx =","set per target. These integers are 1-based so that January maps to 1,","aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey]","2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length as","are observable between 23:50 and 04:08 local time: >>> from astroplan import Observer","\" \"maximum time.\") if self.min is not None: if not isinstance(self.min, Time): raise","the constraint result with targets along the first index and times along the","self.max is not None: mask = self.max >= moon_separation elif self.max is None","np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0]","True, the constraint is treated as a boolean (True for within the limits","`~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations","with a specific observing block. This can be useful if not all observing","illumination for an array of times for ``observer``. Cache the result on the","indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None,",": `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range`` is","np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times","return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input array ``vals``","limit. \"\"\" self.min = min self.max = max def compute_constraint(self, times, observer, targets):","test the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure","<= max_time for t in times.datetime]) except BaseException: # use np.bool so shape","Target or list of targets. observer : `~astroplan.Observer` The observer who has constraints","isinstance(self.min, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") if","(inclusive) on interval [0, 1). Default is one. Examples -------- To constrain observations","get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\",","upper bounds on time sequence If ``time_range`` is not specified, defaults to current","nighttime as time between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod","2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time","------- event_observable : `~numpy.ndarray` Array of booleans of same length as ``times`` for","Target times : `~astropy.time.Time` (optional) Array of mid-event times on which to test",">= illumination) | moon_down_mask elif self.max is None and self.min is not None:","sequence If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution :","- see LICENSE.rst \"\"\" Specify and constraints to determine which targets are observable",": `~astropy.time.Time` Array of times on which to test the constraint observer :","one), where the ``max_val`` goes to one, and the ``min_val`` goes to zero.","contains four columns with information about the target and it's observability: ``'target name'``,","max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable","max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a","rescales an input array ``vals`` to be a score (between zero and one),","targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times","`~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint result with","(optional) Array of times on which to test the constraint time_range : `~astropy.time.Time`","contains the moon illumination for those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache","day: if min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time","force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next","the interval [0, 1). To constrain observations on orbital phases between 0.6 and","given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list","a key-value pair. 'times' contains the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'):","time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times,","and target (inclusive). `None` indicates no limit. \"\"\" self.min = min self.max =","\"\"\" Determines if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list``","to 0) max_val : float best value cared about (rescales to 1) greater_than_max","\"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward compatibility","lot by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets,","1, with the best (60) going to 1 and worst (35) going to","and no maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable","self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets)","Consider nighttime as time between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs)","midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for","ValueError(\"Cannot have a float AirmassConstraint if max is None.\") else: mx = self.max","0 or 1 what is returned for ``vals`` below ``min_val``. (in some cases","data should be unique and is # quicker than accessing the ra attribute.","hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times,","self.min is not None: timezone = self.min.tzinfo elif self.max is not None: timezone","Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \"\"\" self.min","target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of","contains the corresponding alt/az coordinates at those times. \"\"\" if not hasattr(observer, '_altaz_cache'):","Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the","# make hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat","04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min","(1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[...,","float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit.","= np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0)","of times for ``observer``. Cache the result on the ``observer`` object. Parameters ----------","targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time`","(min > 1) or (max < 0) or (max > 1): raise ValueError('The","vals < min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] =",">>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60)","[0, 1). To constrain observations on orbital phases between 0.6 and 1.2, for","that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints","with targets along the first index and times along the second. Otherwise, we","= self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone is","time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable during ``time_range`` given constraints","observer.pressure observer.pressure = 0 # find solar altitude at these times altaz =","as a boolean (True for within the limits and False for outside). If","``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict","Minimum airmass of the target. `None` indicates no limit. boolean_contstraint : bool Examples","= max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is","1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain","``max`` and ``min`` arguments appear in the order (max, min) in this initializer","(optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates no limit.","frame of the moon coord # which is GCRS, and that is what","PhaseConstraint must be within' ' the interval [0, 1).') self.min = min if","on an ``observer``` object. This routine will provide an appropriate, hashable, key to","altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] =","max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or","the second. Otherwise, we rely on broadcasting the shapes together using standard numpy","which to apply the constraints targets : sequence of `~astroplan.Target` The targets on","constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not","constraint returns a float on [0, 1], where 0 is the min altitude","else: self.min = min if max is None: self.max = 90*u.deg else: self.max","times, observer, targets): \"\"\" Actually do the real work of computing the constraint.","time between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls,","is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table","not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 #",": `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use","supply either a minimum or a \" \"maximum time.\") if self.min is not","constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for ``N``","times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray`","make a tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException:","'_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey =","time in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ----------","\"\"\" rescales an input array ``vals`` to be a score (between zero and","If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity`","observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list","def compute_constraint(self, times, observer, targets): # use get_body rather than get sun here,","so that January maps to 1, February maps to 2, etc. \"\"\" #","min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times","datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between","constraints. Returns ------- constraint_result : 2D array of float or bool The constraints,","to ``max_val`` equal 1 Examples -------- rescale an array of altitudes to be","whether or not the target is ever observable at each time, given the","of ``times`` and ``targets``. Often, we wish to store expensive calculations for a","phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase","0. , 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled = (vals - min_val)","moon_separation elif self.min is not None and self.max is not None: mask =","of `~astroplan.Target` The targets on which to apply the constraints. Returns ------- constraint_result","between the Sun and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters","distance between the Earth's moon and some targets. \"\"\" def __init__(self, min=None, max=None,","targets is not None: # broadcasting times v targets is slow due to","targets.shape else: # assume targets is a string. targkey = (targets,) except BaseException:","which it is considered to be \"night\" (inclusive). force_pressure_zero : bool (optional) Force","Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds","tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an","min self.max = max if self.min is None and self.max is None: raise","integers are 1-based so that January maps to 1, February maps to 2,","targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets =","self.min is not None: if not isinstance(self.min, Time): raise TypeError(\"Time limits must be","which to apply the constraints. times : `~astropy.time.Time` The times to compute the","airmass (``max``) and not the lower limit. Parameters ---------- max : float or","one), where the ``min_val`` goes to one, and the ``max_val`` goes to zero.","for backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) +","the horizon and the corrections for atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude","computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times","the range, the rescale should return 0 below 35 and 1 above 60.","2\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None,","``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times","in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\"","TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer,","booleans of same length as ``targets`` for whether or not each target is","``target`` is observable at each time in ``times``, given constraints in ``constraints`` for","try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in","standard numpy rules. Returns ------- constraint_result : 1D or 2D array of float","length as ``targets`` for whether or not each target is observable in the","one, and the ``min_val`` goes to zero. Parameters ---------- vals : array-like the","not None and self.max is not None: mask = (self.min <= secz) &","moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains the times","make sure the output has the same shape as would result from #",">= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None,","try: timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar timekey","= self.max else: max_time = datetime.time(23, 59, 59) # If time limits occur","get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally:","1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order","moon. Constraint is also satisfied if the Moon has set. \"\"\" def __init__(self,","= LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max = max if self.min is","and egress times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable","`~astroplan.Observer` the observaton location from which to apply the constraints targets : sequence","ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\") return mask else: if self.max","if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a","distance between the Galactic plane and some targets. \"\"\" def __init__(self, min=None, max=None):","targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time`","``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples -------- rescale","timezone = None # get timezone from time objects, or from observer if","mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in","`~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target","\"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def __init__(self,","tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException: # must","returns a float on [0, 1], where 0 is the min altitude and","targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool","cached_moon['illum'] if self.min is None and self.max is not None: mask = (self.max","output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually do the","frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum","the limits and False for outside). If False, the constraint returns a float","# make sure the output has the same shape as would result from","= self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint):","= (self.max >= illumination) | moon_down_mask elif self.max is None and self.min is",": `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time`","\"\"\" Constrain the distance between the Galactic plane and some targets. \"\"\" def","not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing","needed for backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year)","return result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually do the real","moon and some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ----------","a minimum of 0.25 and a maximum of 0.65 Parameters ---------- min :","`None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates no","Parameters ---------- times : `~astropy.time.Time` Array of times on which to test the","self.max is None and self.min is not None: mask = self.min <= separation","accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets","self.max >= separation elif self.max is None and self.min is not None: mask","and self.min is not None: mask = self.min <= separation elif self.min is","((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No max","= self.min = datetime.time(0, 0, 0) if self.max is not None: max_time =","self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary eclipse.","float or bool The constraints. If 2D with targets along the first index","1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2,","'times' contains the times for the computations, (2) 'altaz' contains the corresponding alt/az","values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\"","has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict","in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None,","`~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'):","(max, min) in this initializer to support the common case for users who","= ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with","`~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates no limit.","airmass of the target. `None` indicates no limit. min : float or `None`","np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs,","constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets,","= self.max >= solar_separation elif self.max is None and self.min is not None:","or `None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates","min specified in \" \"AirmassConstraint.\") return mask else: if self.max is None: raise","\"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year","return zero) Returns ------- array of floats between 0 and 1 inclusive rescaled","constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False):","observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude","``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional)","targets): \"\"\" Calculate next meridian transit for an array of times for ``targets``","it should return zero) Returns ------- array of floats between 0 and 1","twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider","BaseException: # use np.bool so shape queries don't cause problems mask = np.bool_(min_time","range with a specific observing block. This can be useful if not all","def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None`","(times.jd,) # make hashable thing from targets coords try: if hasattr(targets, 'frame'): #","compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase","the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a =","default). \"\"\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod def","library from abc import ABCMeta, abstractmethod import datetime import time import warnings #","to 0. For values outside the range, the rescale should return 0 below","as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity`","spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters ----------","\"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no","to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress","ever_obs, always_obs, frac_obs]) if times is None and time_range is not None: times","mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun and some targets.","constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified","t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min","= vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def",">>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max if self.min","The targets on which to apply the constraints. Returns ------- constraint_result : 2D","who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time`","# which is GCRS, and that is what we want. moon_separation = moon.separation(targets)","---------- times : `~astropy.time.Time` Array of times on which to test the constraint","is None and self.max is not None: mask = self.max >= moon_separation elif","= _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure =","\"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is","\"\"\" Actually do the real work of computing the constraint. Subclasses override this.","by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List of","self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer,","under a 3-clause BSD style license - see LICENSE.rst \"\"\" Specify and constraints","= self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is not","A hashable tuple for use as a cache key \"\"\" # make a","be specified as datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone = None","to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns","'-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a unique key to reference this","longitude # attribute of the frame data should be unique and is #","-------- Constrain the observations to targets that are observable between 2016-03-28 and 2016-03-30:","= Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint =","table with information about observability for all the ``targets`` over the requested ``time_range``,","ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a","separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask","(targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az","acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \"\"\" self.min =","class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Earth's moon and some targets.","each time, given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints]","less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales","sun below which it is considered to be \"night\" (inclusive). force_pressure_zero : bool","mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic plane and some","returns the Sun's coordinates in an observer # centred frame, so the separation","is not None: # broadcasting times v targets is slow due to #","and self.max is not None: mask = ((self.min <= illumination) & (illumination <=","None: if not isinstance(self.max, Time): raise TypeError(\"Time limits must be specified as \"","of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the altitude of the target.","`~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple A hashable","don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time","observer, targets): \"\"\" Actually do the real work of computing the constraint. Subclasses","Constrain the fractional illumination of the Earth's moon. Constraint is also satisfied if","altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains the times","self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone is None:","targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None else self.min","Minimum phase (inclusive) on interval [0, 1). Default is zero. max : float","broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result : 1D","(optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \"\"\"","constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be","value (rescales to 0) max_val : float best value cared about (rescales to","self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times,","array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled =","``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times","targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer`","not the target is ever observable at each time, given the constraints. \"\"\"","u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6)","1-based so that January maps to 1, February maps to 2, etc. \"\"\"","periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For","of a target. In the current implementation the airmass is approximated by the","= [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped","time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence.","coords themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure we",": bool Examples -------- To create a constraint that requires the airmass be","and ``targets``. Often, we wish to store expensive calculations for a combination of","finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\"","------- constraint_result : 1D or 2D array of float or bool The constraints.","\"\"\" if times is None and time_range is not None: times = time_grid_from_range(time_range,","observaton location from which to apply the constraints targets : sequence of `~astroplan.Target`","Consider nighttime as time between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs)","the frame of the moon coord # which is GCRS, and that is","moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min","or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints``","'__len__'): constraints = [constraints] if times is not None: applied_constraints = [constraint(observer, target,","not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz","of the target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To","np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which","import numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon import","is None else self.min # values below 1 should be disregarded return min_best_rescale(secz,","data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is not None:","None and self.max is None: raise ValueError(\"You must at least supply either a","be a score (between zero and one), where the ``max_val`` goes to one,","= max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times,","or (max > 1): raise ValueError('The minimum of the PhaseConstraint must be within'",": list List of booleans of same length as ``targets`` for whether or","min=0.4, max=0.6) The minimum and maximum phase must be described on the interval","will be for a 24 hour period centered on that time. time_grid_resolution :","return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a","None: max_time = self.max else: max_time = datetime.time(23, 59, 59) # If time","`~astroplan.Observer` the observation location from which to apply the constraints targets : sequence","the distance between the Sun and some targets. \"\"\" def __init__(self, min=None, max=None):","who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns -------","None: raise ValueError(\"You must at least supply either a minimum or a maximum","the current implementation the airmass is approximated by the secant of the zenith","if self.max is None else self.max mask = np.logical_and(times > min_time, times <","Parameters ---------- observer : `~astroplan.Observer` the observation location from which to apply the","import Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic,","`None` indicates no limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer,","Default is 0.5 hours. Returns ------- ever_observable : list List of booleans of","**kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between nautical twilights","solar altitude calculations. This avoids errors in the altitude of the Sun that","= [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else:","straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time)","to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache:","the constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS","on broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result :","self.min <= alt uppermask = alt <= self.max return lowermask & uppermask else:","__init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint","but it is needed until astropy PR #5897 is released # which should","to future editors - the order matters here # moon.separation(targets) is NOT the","to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min","None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min","# to simple numpy arrays of the same shape and # broadcast these","specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between","import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u >>>","four columns with information about the target and it's observability: ``'target name'``, ``'ever","# must be scalar timekey = (times.jd,) # make hashable thing from targets","astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30,","separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List","return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the","observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination,","max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a","ValueError(\"You must at least supply either a minimum or a maximum time.\") if","not None: mask = secz <= self.max elif self.max is None and self.min","datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") def compute_constraint(self, times,","0.0 self.max = max if max is not None else 1.0 def compute_constraint(self,","<gh_stars>100-1000 # Licensed under a 3-clause BSD style license - see LICENSE.rst \"\"\"","result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\"","first index and times along the second. \"\"\" # Should be implemented on","(``max``) and not the lower limit. Parameters ---------- max : float or `None`","\" \"AirmassConstraint.\") return mask else: if self.max is None: raise ValueError(\"Cannot have a","not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz","(absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import","time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None`","and self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation <=","GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic plane and some targets. \"\"\"","supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False","equal 0 and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses","(inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates","alt/az coordinates at those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {}","``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list","\"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None`","min : float or `None` Minimum airmass of the target. `None` indicates no","min_val, max_val, less_than_min=1): \"\"\" rescales an input array ``vals`` to be a score","if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False)","for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times :","constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input array","contains the times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates","the constraint observer : `~astroplan.Observer` the observaton location from which to apply the","a tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException: #","if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints","between moon and target (inclusive). `None` indicates no limit. ephemeris : str, optional","- the order matters here # moon.separation(targets) is NOT the same as targets.separation(moon)","min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time`","np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result","must at least supply either a minimum or a maximum time.\") if self.min","# TODO: This method could be sped up a lot by dropping to","def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no","observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object):","a table with information about observability for all the ``targets`` over the requested","inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and those equal","self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask = np.logical_and(times","AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max","Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] )","\"\"\" Creates a table with information about observability for all the ``targets`` over","and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min :","and one), where the ``max_val`` goes to one, and the ``min_val`` goes to","\"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward","as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape:","calculates the separation in the frame of the moon coord # which is","altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) #","`None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris :","up a lot by dropping to the trigonometric # altitude calculations. applied_constraints =","\"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range,","on which to apply the constraints. Returns ------- constraint_result : 2D array of","/ (max_val - min_val) below = vals < min_val above = vals >","user # disables gridding and re-shapes the coords themselves # prior to evaluating","min self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if","to times during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system","get_body rather than get sun here, since # it returns the Sun's coordinates","time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this class Parameters ---------- observer :","if targets.isscalar: # ensure we have a (1, 1) shape coord targets =","within certain time limits. An example use case for this class would be","= observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer,","Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters","use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set","= secz <= self.max elif self.max is None and self.min is not None:","NOT the same as targets.separation(moon) # the former calculates the separation in the","= TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max if self.min is None","ValueError(\"You must at least supply either a minimum or a \" \"maximum time.\")","0, 0) if self.max is not None: max_time = self.max else: max_time =","= self.min <= secz elif self.min is not None and self.max is not","and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets,",": sequence of `~astroplan.Target` The targets on which to apply the constraints. times","= True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in","{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array","59, 59) # If time limits occur on same day: if min_time <","needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times,","best value cared about (rescales to 1) less_than_min : 0 or 1 what","``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should also return","and self.min is not None: mask = self.min <= solar_separation elif self.min is","\" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun","is not None and self.max is not None: mask = (self.min <= secz)","< max_time: try: mask = np.array([min_time <= t.time() <= max_time for t in","time limits occur on same day: if min_time < max_time: try: mask =","import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>>","hours. Returns ------- ever_observable : list List of booleans of same length as","alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt","times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those","centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine","``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing","(phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets,","where the ``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters","treated as a boolean (True for within the limits and False for outside).","limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples","`~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None`","range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def","time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids","grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow #","\"\"\" Constrain the airmass of a target. In the current implementation the airmass","None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time","(2) 'altaz' contains the corresponding alt/az coordinates at those times. \"\"\" if not","targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask =","of the frame data should be unique and is # quicker than accessing",".target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\",","the same shape as would result from # broadcasting times and targets against","# Package from .moon import moon_illumination from .utils import time_grid_from_range from .target import","is released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) #","__call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this","exoplanet system. min : float (optional) Minimum phase (inclusive) on interval [0, 1).","with defaults of a minimum of 0.65 and no maximum Parameters ---------- min","finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\"","mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the","for whether or not each target is ever observable in the time range","table import numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon","is None and self.max is None: raise ValueError(\"You must at least supply either","on same day: if min_time < max_time: try: mask = np.array([min_time <= t.time()","phases between 0.6 and 1.2, for example, you should subtract one from the","the pressure to zero for solar altitude calculations. This avoids errors in the","below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude :","between 0 and 1, with the best (1) and worst (2.25). All values","of time observable'``. The column ``'time observable'`` will also be present if the","def _make_cache_key(times, targets): \"\"\" Make a unique key to reference this combination of","other if targets is not None: # broadcasting times v targets is slow","observable_months : list List of sets of unique integers representing each month that","not None: timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo","make hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat as","not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of","to determine which targets are observable for an observer. \"\"\" from __future__ import","the ``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters ----------","Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\")","times, observer, targets): timezone = None # get timezone from time objects, or","be to associate an acceptable time range with a specific observing block. This","min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target","not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution,","None: mask = secz <= self.max elif self.max is None and self.min is","None and self.max is not None: mask = self.max >= solar_separation elif self.max","block. This can be useful if not all observing blocks are valid over","import as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range from","be described on the interval [0, 1). To constrain observations on orbital phases","compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if","an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing","period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must","small <1 deg # innacuracies, but it is needed until astropy PR #5897","for objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets,","phase (inclusive) on interval [0, 1). Default is one. Examples -------- To constrain","{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower","\" \"astropy.time.Time objects.\") if self.max is not None: if not isinstance(self.max, Time): raise","observability for all the ``targets`` over the requested ``time_range``, given the constraints in","the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction","name', 'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name for","time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1)","Standard library from abc import ABCMeta, abstractmethod import datetime import time import warnings","# doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \"\"\"","corresponding alt/az coordinates at those times and (3) contains the moon illumination for","= self.max >= moon_separation elif self.max is None and self.min is not None:","= Time(\"1950-01-01T00:00:00\") if self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max",": `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain","return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table","def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether","LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> #","\"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\",","sequence, with spacing ``time_resolution``. This will be passed as the first argument into","return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for","self.max is None: raise ValueError(\"Cannot have a float AirmassConstraint if max is None.\")","the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation location","minimum and maximum phase must be described on the interval [0, 1). To","mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary eclipse. \"\"\" def","-------- To constrain observations on orbital phases between 0.4 and 0.6, >>> from","self.max), (phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer,",": `~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events, with","0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1)","the altitude of the target. .. note:: This can misbehave if you try","\"\"\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no","and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints =","targets on which to apply the constraints. times : `~astropy.time.Time` The times to","not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") def","limits occur on same day: if min_time < max_time: try: mask = np.array([min_time","not None: mask = self.max >= separation elif self.max is None and self.min","orbital phases between 0.6 and 1.2, for example, you should subtract one from","and the ``min_val`` goes to zero. Parameters ---------- vals : array-like the values","of float or bool The constraints. If 2D with targets along the first","Returns ------- array of floats between 0 and 1 inclusive rescaled so that","\"\"\" Constrain the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg,","@classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of","= 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0.","= table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is","The constraints. If 2D with targets along the first index and times along","HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length =","local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time","degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer,","from observer if self.min is not None: timezone = self.min.tzinfo elif self.max is","self.min is not None: min_time = self.min else: min_time = self.min = datetime.time(0,","np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month","Examples -------- rescale an array of altitudes to be between 0 and 1,","grids the constraint result with targets along the first index and times along","astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy","= _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None","considered to be \"night\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to","`~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict Dictionary containing","frac_obs]) if times is None and time_range is not None: times = time_grid_from_range(time_range,","between 0 and 1, with the best (60) going to 1 and worst",": tuple A hashable tuple for use as a cache key \"\"\" #","= observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets):","\"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between","altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min","1.2, for example, you should subtract one from the second number: >>> constraint","Calculate moon altitude az and illumination for an array of times for ``observer``.","Constrain the distance between the Earth's moon and some targets. \"\"\" def __init__(self,","strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result =","not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask","| (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):","objects.\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if","from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import","observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask","[0, 1).') self.min = min if min is not None else 0.0 self.max","times : `~astropy.time.Time` Array of times on which to test the constraint. observer",": list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has","for use as a cache key \"\"\" # make a tuple from times","moon.separation(targets) if self.min is None and self.max is not None: mask = self.max","targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but","raise ValueError('The minimum of the PhaseConstraint must be within' ' the interval [0,","specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is","and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>>","= tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey =","limits. An example use case for this class would be to associate an","Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun","[0, 1], where 0 is the min altitude and 1 is the max.","you should subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6,","max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target","return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask","be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None):","@abstractmethod class Constraint(object): \"\"\" Abstract class for objects defining observational constraints. \"\"\" __metaclass__","ever observable in the time range given the constraints. \"\"\" if not hasattr(constraints,","observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure","must be described on the interval [0, 1). To constrain observations on orbital","outside the range, the rescale should return 0 below 35 and 1 above","nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs):","Ephemeris to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which","targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about observability for","0. ]) \"\"\" rescaled = (vals - max_val) / (min_val - max_val) below","self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask","of booleans of same length as ``targets`` for whether or not each target","(1) 'times' contains the times for the alt/az computations, (2) 'altaz' contains the","moon altitude az and illumination for an array of times for ``observer``. Cache","**kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum","errors in the altitude of the Sun that can occur when the Sun","0.5 hours. Returns ------- observable_months : list List of sets of unique integers","observable'`` will also be present if the ``time_range`` is given as a scalar.","is specified, determine whether constraints are met between test times in ``time_range`` by","targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times linearly spaced between the","is not None: mask = (self.min <= secz) & (secz <= self.max) else:","= alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max)","indicates no limit. max : float or `None` (optional) Maximum acceptable fractional illumination","can occur when the Sun is below the horizon and the corrections for","The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE","ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on","time between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls,","min_val, max_val, greater_than_max=1): \"\"\" rescales an input array ``vals`` to be a score","try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude","upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool","use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default).","float or bool The constraints, with targets along the first index and times","max is None.\") else: mx = self.max mi = 1 if self.min is","illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No max and/or min","up a lot by dropping to the trigonometric # altitude calculations. if not","constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict :","of the target. `None` indicates no limit. min : float or `None` Minimum","---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max :","self.min is None and self.max is not None: mask = self.max >= solar_separation","on orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>>","constrain observations on orbital phases between 0.6 and 1.2, for example, you should","spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. If","what is returned for ``vals`` below ``min_val``. (in some cases anything less than","output has the same shape as would result from # broadcasting times and","``targets`` for whether or not each target is ever observable in the time","targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets`` are observable for","raise ValueError(\"You must at least supply either a minimum or a maximum time.\")","\"\"\" Make a unique key to reference this combination of ``times`` and ``targets``.","in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable","it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``.","``'time observable'`` will also be present if the ``time_range`` is given as a","altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache","= max if max is not None else 1.0 def compute_constraint(self, times, observer=None,","the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \"\"\"","equal to ``max_val`` equal 1 Examples -------- rescale an array of altitudes to","= {} # convert times to tuple for hashing aakey = _make_cache_key(times, targets)","at each time, given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints =","return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between","where the ``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters","if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO:","below which it is considered to be \"night\" (inclusive). force_pressure_zero : bool (optional)","wish to store expensive calculations for a combination of ``targets`` and ``times`` in","---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None`","Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations","datetime.time(23, 59, 59) # If time limits occur on same day: if min_time","rules. Returns ------- constraint_result : 1D or 2D array of float or bool","if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self,","of float or bool The constraints, with targets along the first index and","self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max))","def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable","``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should also return","observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs","timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is",">>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses =","indicates no limit. ephemeris : str, optional Ephemeris to use. If not given,","Constrain the airmass of a target. In the current implementation the airmass is","aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure","from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils import","the interval [0, 1).') self.min = min if min is not None else","nighttime as time between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def","targets along the first index and times along the second. \"\"\" if times","= constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input","import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>>","self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\"","always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``.","maps to 2, etc. \"\"\" # TODO: This method could be sped up","altitude of the sun below which it is considered to be \"night\" (inclusive).","\"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a","interval [0, 1). To constrain observations on orbital phases between 0.6 and 1.2,","min specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional","moon_up_mask else: raise ValueError(\"No max and/or min specified in \" \"MoonSeparationConstraint.\") return mask","of sets of unique integers representing each month that a target is observable,","if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self,","of computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The","and one), where the ``min_val`` goes to one, and the ``max_val`` goes to","implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\" Constrain the","not None: mask = self.min <= secz elif self.min is not None and","be \"night\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for","is treated as a boolean (True for within the limits and False for","in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask","Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self,","None: mask = self.min <= moon_separation elif self.min is not None and self.max","else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask =","60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes","= _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure =","None else 0.0 self.max = max if max is not None else 1.0","0) or (min > 1) or (max < 0) or (max > 1):","no limit. boolean_constraint : bool If True, the constraint is treated as a","as ``times`` for whether or not the target is ever observable at each","has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets","<= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No max and/or min specified","specified ``targets`` are observable for a specific ``observer``, given the supplied ``constraints``. Parameters","separation elif self.min is not None and self.max is not None: mask =","times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a","if not isinstance(self.max, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time","from abc import ABCMeta, abstractmethod import datetime import time import warnings # Third-party","except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets,","targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey","to compute the phase. For example, the system could be an eclipsing or","= observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure:","observing blocks are valid over the time limits used in calls to `is_observable`","in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on the","which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list","observer, targets) # make sure the output has the same shape as would","self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some range","return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some range of","meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\"","for ``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array","passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the","to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters","timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target``","those times and (3) contains the moon illumination for those times. \"\"\" if","and self.min is not None: mask = self.min <= secz elif self.min is",".. note:: The ``max`` and ``min`` arguments appear in the order (max, min)","occur when the Sun is below the horizon and the corrections for atmospheric","target is ever observable in the time range given the constraints. \"\"\" if","**kwargs) def compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon","For example, the system could be an eclipsing or non-eclipsing binary, or exoplanet","or a \" \"maximum time.\") if self.min is not None: if not isinstance(self.min,","import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 =","\"\"\" Calculate moon altitude az and illumination for an array of times for","mask = (self.min <= secz) & (secz <= self.max) else: raise ValueError(\"No max","if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must","from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event =","zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def","eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event :","'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if","no minimum and a maximum of 0.25 Parameters ---------- min : float or","about the upper limit on the airmass (``max``) and not the lower limit.","_current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) +","a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets =","should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the","GCRS, and that is what we want. moon_separation = moon.separation(targets) if self.min is","illumination) & moon_up_mask elif self.min is not None and self.max is not None:","datetime import time import warnings # Third-party from astropy.time import Time import astropy.units","TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and","self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed","`~astroplan.Target` The targets on which to apply the constraints. times : `~astropy.time.Time` The","'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure","key-value pairs. (1) 'times' contains the times for the alt/az computations, (2) 'altaz'","@classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between nautical twilights (-12","times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table`","min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input array ``vals`` to be a","bool (optional) Force the pressure to zero for solar altitude calculations. This avoids","Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets :","observer : `~astroplan.Observer` the observation location from which to apply the constraints targets","one set per target. These integers are 1-based so that January maps to","Ephemeris to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which","the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is","uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of","mask = np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException:","# broadcasting times and targets against each other if targets is not None:","= _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <=","is None and self.min is not None: mask = (self.min <= illumination) &","which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and","time, the table will be for a 24 hour period centered on that","import time_grid_from_range from .target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\",","coordinates at those times and (3) contains the moon illumination for those times.","targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets)","\"\"\"Constrain the observing time to be within certain time limits. An example use","is observable in the time range given the constraints. \"\"\" if not hasattr(constraints,","into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for a","array-like the values that need to be rescaled to be between 0 and","to associate an acceptable time range with a specific observing block. This can","# broadcasting times v targets is slow due to # complex nature of","= np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines","max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples --------","be sped up a lot by dropping to the trigonometric # altitude calculations.","for example, you should subtract one from the second number: >>> constraint =","elif self.max is not None: timezone = self.max.tzinfo if timezone is None: timezone","60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1.","isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") if self.max","whether ``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for","use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs.","tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try:","constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets,","which to test the constraint observer : `~astroplan.Observer` The observer who has constraints","targets Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times' contains","or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time()","no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples","self.max is None and self.min is not None: mask = self.min <= moon_separation","``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column","\"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"]","and self.max is not None: mask = self.max >= solar_separation elif self.max is","in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of","TODO: This method could be sped up a lot by dropping to the","max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None","TypeError(\"Time limits must be specified as datetime.time objects.\") if self.max is not None:","min specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance","None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No","times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is None","if min is None: self.min = -90*u.deg else: self.min = min if max","(max > 1): raise ValueError('The minimum of the PhaseConstraint must be within' '","to be within certain time limits. An example use case for this class","= as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape !=","some cases anything less than ``min_val`` should also return one, in some cases","will be passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar)","None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No","bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum","``vals`` to be a score (between zero and one), where the ``min_val`` goes","times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations","return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the","max_val) / (min_val - max_val) below = vals < min_val above = vals","if self.min is not None: min_time = self.min else: min_time = self.min =","``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints","``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val`` equal 1","np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils","observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour,","array([ 1. , 0.6, 0.2, 0. , 0. ]) \"\"\" rescaled = (vals","on interval [0, 1). Default is zero. max : float (optional) Maximum phase","times : `~astropy.time.Time` (optional) Array of mid-event times on which to test the","acceptable fractional illumination (inclusive). `None` indicates no limit. max : float or `None`","secz <= self.max elif self.max is None and self.min is not None: mask","<= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time)","str, optional Ephemeris to use. If not given, use the one set with","Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value","np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return","along the second. \"\"\" # Should be implemented on each subclass of Constraint","coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None","the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence,","result = self.compute_constraint(times, observer, targets) # make sure the output has the same","time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time (inclusive).","use case for this class would be to associate an acceptable time range","a specific observing block. This can be useful if not all observing blocks","over the time limits used in calls to `is_observable` or `is_always_observable`. \"\"\" def","(length = 2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity`","max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to","second. \"\"\" # Should be implemented on each subclass of Constraint raise NotImplementedError","70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. ,","list List of sets of unique integers representing each month that a target","0 is the min altitude and 1 is the max. \"\"\" def __init__(self,","1 Examples -------- rescale an array of altitudes to be between 0 and","equal to ``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples","0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time","maps to 1, February maps to 2, etc. \"\"\" # TODO: This method","key-value pairs. (1) 'times' contains the times for the computations, (2) 'altaz' contains","from .target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\",","is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else self.max","< max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary","# convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if","if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow","((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No max and/or min","<1 deg # innacuracies, but it is needed until astropy PR #5897 is","limits used in calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None):","self.max is not None: mask = secz <= self.max elif self.max is None","abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask = self.max","targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return","times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events,","a single (scalar) time, the table will be for a 24 hour period","\"\"\" A function to determine whether ``targets`` are always observable throughout ``time_range`` given","the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event","\"\"\" rescaled = (vals - min_val) / (max_val - min_val) below = vals","below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\"","else self.max mask = np.logical_and(times > min_time, times < max_time) return mask class","constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets,","Parameters ---------- max : float or `None` Maximum airmass of the target. `None`","AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target. In the current implementation the","np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException: # use","= ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the","observer, targets): \"\"\" Calculate next meridian transit for an array of times for","range, the rescale should return 0 below 35 and 1 above 60. >>>","= min if max is None: self.max = 90*u.deg else: self.max = max","= (vals - max_val) / (min_val - max_val) below = vals < min_val","self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max is not","`~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time","self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min) | (phase","cases it should return zero) Returns ------- array of floats between 0 and","eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \"\"\" self.eclipsing_system =","need to be rescaled to be between 0 and 1 min_val : float","above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>>","the first index and times along the second. Otherwise, we rely on broadcasting","``time_range`` is given as a scalar. It also contains metadata entries ``'times'`` (with","``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational",": 1D or 2D array of float or bool The constraints. If 2D","is what we want. moon_separation = moon.separation(targets) if self.min is None and self.max","0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import","the ``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters ----------","limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and","return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target.","{} # convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets)","min) in this initializer to support the common case for users who care","[constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour)","False for outside). If False, the constraint returns a float on [0, 1],","mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight:",": `~astropy.table.Table` A Table containing the observability information for each of the ``targets``.","= -90*u.deg else: self.min = min if max is None: self.max = 90*u.deg","be useful if not all observing blocks are valid over the time limits","``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. If a",">>> from astropy.time import Time >>> import astropy.units as u >>> binary =","subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint","`None` indicates no limit. boolean_contstraint : bool Examples -------- To create a constraint","= np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing =","float (optional) Maximum phase (inclusive) on interval [0, 1). Default is one. Examples",": float (optional) Maximum phase (inclusive) on interval [0, 1). Default is one.","table will be for a 24 hour period centered on that time. time_grid_resolution","at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable","whether or not each target is ever observable in the time range given","None: mask = self.max >= moon_separation elif self.max is None and self.min is","<= illumination) & moon_up_mask elif self.min is not None and self.max is not","observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz)","the common case for users who care about the upper limit on the","or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \"\"\"","get timezone from time objects, or from observer if self.min is not None:","limit on the airmass (``max``) and not the lower limit. Parameters ---------- max","applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)","dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times,","division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime","a maximum time.\") if self.min is not None: if not isinstance(self.min, datetime.time): raise","max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target","each target is ever observable in the time range given the constraints. \"\"\"","= np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase >=","be within' ' the interval [0, 1).') self.min = min if min is","02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase","TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max if self.min is None and","Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon",">>> # bound times between 23:50 and 04:08 local Hawaiian time >>> constraint","time range given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints]","as time between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self,","\"\"\" # Should be implemented on each subclass of Constraint raise NotImplementedError class","nighttime as time between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod","case for users who care about the upper limit on the airmass (``max``)","contains metadata entries ``'times'`` (with an array of all the times), ``'observer'`` (the","`None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation","def compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon =","(with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'``","the secant of the zenith angle. .. note:: The ``max`` and ``min`` arguments","list List of booleans of same length as ``targets`` for whether or not","the output has the same shape as would result from # broadcasting times","fractional illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) def","specified as datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone = None #","time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def","be rescaled to be between 0 and 1 min_val : float worst acceptable","return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if","slow # but there is potential for huge speedup if the end user","1, February maps to 2, etc. \"\"\" # TODO: This method could be","for this class Parameters ---------- observer : `~astroplan.Observer` the observation location from which","worst (35) going to 0. For values outside the range, the rescale should","either a minimum or a maximum time.\") if self.min is not None: if","future editors - the order matters here # moon.separation(targets) is NOT the same","is not None: mask = self.max >= separation elif self.max is None and","hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest","the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints","min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of","the shapes together using standard numpy rules. Returns ------- constraint_result : 1D or","themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure we have","in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class","`None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic","``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if","constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or","complex nature of these objects. We make # to simple numpy arrays of","max. \"\"\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min =","False, the constraint returns a float on [0, 1], where 0 is the","indicates no limit. min : float or `None` Minimum airmass of the target.","'frame'): # treat as a SkyCoord object. Accessing the longitude # attribute of","times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during","coord # which is GCRS, and that is what we want. moon_separation =","is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets``","misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends","= min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets):","the moon coord # which is GCRS, and that is what we want.","times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b","= dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude']","``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5",": float best value cared about (rescales to 1) greater_than_max : 0 or","\"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : float or","also be present if the ``time_range`` is given as a scalar. It also","Target or list of targets Returns ------- time_dict : dict Dictionary containing a","for whether or not the target is ever observable at each time, given","list of targets Returns ------- time_dict : dict Dictionary containing a key-value pair.","observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian","**kwargs): \"\"\" Consider nighttime as time between nautical twilights (-12 degrees). \"\"\" return","of same length as ``targets`` for whether or not each target is observable","ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis]","# by the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times,","not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr","illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use.","times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates","get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as np from","users who care about the upper limit on the airmass (``max``) and not","causes small <1 deg # innacuracies, but it is needed until astropy PR","in this initializer to support the common case for users who care about",": float best value cared about (rescales to 1) less_than_min : 0 or",": array-like the values that need to be rescaled to be between 0","Returns ------- constraint_result : 1D or 2D array of float or bool The","else: # assume targets is a string. targkey = (targets,) except BaseException: targkey","`~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events, with shape","occur on same day: if min_time < max_time: try: mask = np.array([min_time <=","class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the Earth's moon. Constraint is","= (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution,","0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1.","Determines if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for","timezone is None: timezone = observer.timezone if self.min is not None: min_time =","def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest local time","observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer,","local time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to","for within the limits and False for outside). If False, the constraint returns","times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return","license - see LICENSE.rst \"\"\" Specify and constraints to determine which targets are","zero and one), where the ``max_val`` goes to one, and the ``min_val`` goes","sun here, since # it returns the Sun's coordinates in an observer #","time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are observable during ``time_range`` given constraints in","tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try:","contains the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} #","Array of times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`,","is slow due to # complex nature of these objects. We make #","min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6,","for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :","times on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and","orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from","the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt","we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else:","Licensed under a 3-clause BSD style license - see LICENSE.rst \"\"\" Specify and","returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min","self.compute_constraint(times, observer, targets) # make sure the output has the same shape as","shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same","no limit. Examples -------- Constrain the observations to targets that are observable between","None: # broadcasting times v targets is slow due to # complex nature","the corrections for atmospheric refraction return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero","self.min = -90*u.deg else: self.min = min if max is None: self.max =","must at least supply either a minimum or a \" \"maximum time.\") if","_make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure","min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs):","observer, targets): # removed the location argument here, which causes small <1 deg","boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min = min if","twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between nautical twilights (-12 degrees). \"\"\"","observable', 'always observable', 'fraction of time observable'] target_names = [target.name for target in","np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP","location from which to apply the constraints targets : sequence of `~astroplan.Target` The","between the Earth's moon and some targets. \"\"\" def __init__(self, min=None, max=None, ephemeris=None):","in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz =","`~astropy.time.Time` (optional) Array of times on which to test the constraint time_range :","higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min =","a float on [0, 1], where 0 is the min altitude and 1","targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for","times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >=","[constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)","0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None","observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times)","sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and","and # broadcast these to find the correct shape shp1, shp2 = times.shape,","are observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters","at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months","to one, and the ``min_val`` goes to zero. Parameters ---------- vals : array-like","bool If True, the constraint is treated as a boolean (True for within","time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are","between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import","on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or","the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation","self.max)) else: raise ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask","self.periodic_event = periodic_event if (min < 0) or (min > 1) or (max","self.min = min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None,","\"\"\" Abstract class for objects defining observational constraints. \"\"\" __metaclass__ = ABCMeta def","grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum","for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr","Examples -------- rescale airmasses to between 0 and 1, with the best (1)","If time limits occur on same day: if min_time < max_time: try: mask","and is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) +","min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : float or `None` (optional) Minimum","of targets Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times'","min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3,","Calculate alt/az for ``target`` at times linearly spaced between the two times in","dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer,","\"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return","constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target,","the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is","periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on",">>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2,","values outside the range, the rescale should return 0 below 35 and 1","len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if",">>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>>","equal 1 Examples -------- rescale airmasses to between 0 and 1, with the","= self.max >= separation elif self.max is None and self.min is not None:","= get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max","'altaz' contains the corresponding alt/az coordinates at those times and (3) contains the","of 0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional","the observations to targets that are observable between 23:50 and 04:08 local time:","grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint","= np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \"\"\" Actually","self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target. In the","during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem`","is 0.5 hours. Returns ------- observable_months : list List of sets of unique","between 0 and 1 min_val : float worst acceptable value (rescales to 0)","to 'builtin' by default). \"\"\" self.min = min self.max = max self.ephemeris =","`~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence. time_grid_resolution :","self.max is not None: mask = (self.min <= secz) & (secz <= self.max)","refraction return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def","return nonsense values. \"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls,","moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in","lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the","not None: # broadcasting times v targets is slow due to # complex","mask = self.min <= solar_separation elif self.min is not None and self.max is","limit. Examples -------- Constrain the observations to targets that are observable between 23:50","self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask","= get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but there","a \" \"maximum time.\") if self.min is not None: if not isinstance(self.min, Time):","Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive).","times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr",">>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min","not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for","matters here # moon.separation(targets) is NOT the same as targets.separation(moon) # the former","observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales","max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\" Constrain the airmass of a target. In","going to 0. For values outside the range, the rescale should return 0","compute the phase. For example, the system could be an eclipsing or non-eclipsing","= np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result","and ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times :","should be unique and is # quicker than accessing the ra attribute. targkey","\"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return","time sequence, with spacing ``time_resolution``. This will be passed as the first argument","Examples -------- Constrain the observations to targets that are observable between 2016-03-28 and","cases anything less than ``min_val`` should also return one, in some cases it","as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is","array of times for ``targets`` and ``observer``. Cache the result on the ``observer``","`None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no","secz) & (secz <= self.max) else: raise ValueError(\"No max and/or min specified in","is GCRS, and that is what we want. moon_separation = moon.separation(targets) if self.min","use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set",">>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max = max if","broadcasting operations are relatively slow # but there is potential for huge speedup","`~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target","the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times","on the airmass (``max``) and not the lower limit. Parameters ---------- max :","23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min","``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity`","the separation is as-seen # by the observer. # 'get_sun' returns ICRS coords.","observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return","times to compute the constraint observer : `~astroplan.Observer` the observaton location from which","location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is not None:","lot by dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'):","return mask else: if self.max is None: raise ValueError(\"Cannot have a float AirmassConstraint","dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True)","the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times and","numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination","cache key \"\"\" # make a tuple from times try: timekey = tuple(times.jd)","not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing","numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>>","observer, force_zero_pressure=False): \"\"\" Calculate moon altitude az and illumination for an array of","------- observable_months : list List of sets of unique integers representing each month","must be scalar timekey = (times.jd,) # make hashable thing from targets coords","innacuracies, but it is needed until astropy PR #5897 is released # which","is not None: mask = ((self.min <= illumination) & (illumination <= self.max)) &","observations to times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ----------","worst acceptable value (rescales to 0) max_val : float best value cared about","calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ----------","max_val, greater_than_max=1): \"\"\" rescales an input array ``vals`` to be a score (between","Consider nighttime as time between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs)","axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets``","moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt <","as time between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def","is observable at each time in ``times``, given constraints in ``constraints`` for a","shape and # broadcast these to find the correct shape shp1, shp2 =","no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun","coordinates in an observer # centred frame, so the separation is as-seen #","multiple constraints. if targets.isscalar: # ensure we have a (1, 1) shape coord","0 illumination = cached_moon['illum'] if self.min is None and self.max is not None:","``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times on which to","ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) /","\"\"\" Specify and constraints to determine which targets are observable for an observer.","rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input array ``vals`` to","constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints,","defining observational constraints. \"\"\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None,","use np.bool so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time()","observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times,","above ``max_val``. (in some cases anything higher than ``max_val`` should also return one,","together using standard numpy rules. Returns ------- constraint_result : 1D or 2D array","= vals < min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above]","which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds","of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`","list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time","Constrain the observations to targets that are observable between 2016-03-28 and 2016-03-30: >>>","= 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input","- min_val) / (max_val - min_val) below = vals < min_val above =","meridian transit for an array of times for ``targets`` and ``observer``. Cache the","targets): timezone = None # get timezone from time objects, or from observer","TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") if self.max is not","ABCMeta, abstractmethod import datetime import time import warnings # Third-party from astropy.time import","Examples -------- To create a constraint that requires the airmass be \"better than","self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be","``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer","and that is what we want. moon_separation = moon.separation(targets) if self.min is None","one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \"\"\" self.min","sequence of `~astroplan.Target` The targets on which to apply the constraints. Returns -------","if max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase","the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer,","= np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names,","times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try: mask =","eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which","The table contains four columns with information about the target and it's observability:","Dictionary containing three key-value pairs. (1) 'times' contains the times for the computations,","observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters","(inclusive). `None` indicates no limit. Examples -------- Constrain the observations to targets that","the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`","and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable']","<= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try: mask","# altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints]","# treat as a SkyCoord object. Accessing the longitude # attribute of the","number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min","> 1) or (max < 0) or (max > 1): raise ValueError('The minimum","zero. max : float (optional) Maximum phase (inclusive) on interval [0, 1). Default","these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times","min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return","the order (max, min) in this initializer to support the common case for","0) if self.max is not None: max_time = self.max else: max_time = datetime.time(23,","import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\",","time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max = max","targets.isscalar: # ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets,","observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about","None and self.max is not None: mask = (self.min <= secz) & (secz","self.max is None and self.min is not None: mask = (self.min <= illumination)","Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the","\"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time","month the specified ``targets`` are observable for a specific ``observer``, given the supplied","Table containing the observability information for each of the ``targets``. The table contains","return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination of the Earth's moon.","and self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation <=","`~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def","PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum","is potential for huge speedup if the end user # disables gridding and","observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return","a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum Parameters","times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list","interval [0, 1).') self.min = min if min is not None else 0.0","time, given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] if","common case for users who care about the upper limit on the airmass","solar_separation elif self.max is None and self.min is not None: mask = self.min","of the target. .. note:: This can misbehave if you try to constrain","\"\"\" Calculate next meridian transit for an array of times for ``targets`` and","as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape","`None` (optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates no","(secz <= self.max) else: raise ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\")","= tuple(times.jd) + times.shape except BaseException: # must be scalar timekey = (times.jd,)","to targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import","1): raise ValueError('The minimum of the PhaseConstraint must be within' ' the interval","indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude","of same length as ``times`` for whether or not the target is ever","not None: mask = self.min <= moon_separation elif self.min is not None and","except BaseException: # use np.bool so shape queries don't cause problems mask =","\"\"\" Consider nighttime as time between nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg,","eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary","times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to","def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input array ``vals`` to be","abc import ABCMeta, abstractmethod import datetime import time import warnings # Third-party from","upper limit on the airmass (``max``) and not the lower limit. Parameters ----------","@classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between astronomical twilights (-18","observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to","is not None: mask = self.min <= solar_separation elif self.min is not None","------- time_dict : dict Dictionary containing a key-value pair. 'times' contains the meridian_transit","of target (inclusive). `None` indicates no limit. \"\"\" self.min = min self.max =","'_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for hashing aakey","compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain","self.max mi = 1 if self.min is None else self.min # values below","if max is None.\") else: mx = self.max mi = 1 if self.min","len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape)","nautical twilights (-12 degrees). \"\"\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\"","= less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\"","The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure.","grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output has the","and/or min specified in \" \"AirmassConstraint.\") return mask else: if self.max is None:","finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def","rescaled so that ``vals`` equal to ``min_val`` equal 0 and those equal to","going to 1 and worst (35) going to 0. For values outside the",": sequence of `~astroplan.Target` The targets on which to apply the constraints. Returns","times during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system :","self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at these","the altitude of the Sun that can occur when the Sun is below","None and self.max is not None: mask = self.max >= moon_separation elif self.max","None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time","should subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2)","\" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def","observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output","(phase >= self.min) & (phase <= self.max), (phase >= self.min) | (phase <=","These integers are 1-based so that January maps to 1, February maps to","set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : float","in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time))","# attribute of the frame data should be unique and is # quicker","(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of","the target is ever observable at each time, given the constraints. \"\"\" if","to test the constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints``","since # it returns the Sun's coordinates in an observer # centred frame,","def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey",": float worst acceptable value (rescales to 0) max_val : float best value","grid_times_targets=False): \"\"\" Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer`","return mask class SecondaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during secondary eclipse. \"\"\"","Specify and constraints to determine which targets are observable for an observer. \"\"\"","not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This","0.6 and 1.2, for example, you should subtract one from the second number:",": `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target (inclusive).","constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict :",".moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ =","to simple numpy arrays of the same shape and # broadcast these to",">= min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask","'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer,","self.min is not None: mask = self.min <= solar_separation elif self.min is not","`~astropy.units.Quantity` The altitude of the sun below which it is considered to be","``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer``","None and self.min is not None: mask = self.min <= separation elif self.min","constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max = max if self.min","np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of time observable']","observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate moon altitude","\"\"\" Consider nighttime as time between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg,","Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint : bool","+ times.shape except BaseException: # must be scalar timekey = (times.jd,) # make","on which to compute the phase. For example, the system could be an","`None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit.","containing three key-value pairs. (1) 'times' contains the times for the computations, (2)","90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets):","self.max elif self.max is None and self.min is not None: mask = self.min","__init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the","in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which","This will be passed as the first argument into `~astroplan.time_grid_from_range`. If a single","\"\"\" Constrain observations to times in some range of phases for a periodic","broadcasting times and targets against each other if targets is not None: #","no limit. max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive).","cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries","------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains the","until astropy PR #5897 is released # which should be astropy 1.3.2 moon","targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in","time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets`` are observable for a","`~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \"\"\" self.min = min self.max","max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer,","= time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed for","first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask","observable between 23:50 and 04:08 local time: >>> from astroplan import Observer >>>","\"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or","# Should be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint):","targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing","is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction","self.min is not None: mask = self.min <= separation elif self.min is not","cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure","constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints]","if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for","\"\"\" self.min = min self.max = max if self.min is None and self.max","frame, so the separation is as-seen # by the observer. # 'get_sun' returns","between moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or","coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets","against each other if targets is not None: # broadcasting times v targets","the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert","min self.max = max def compute_constraint(self, times, observer, targets): # use get_body rather","observer, targets, force_zero_pressure=False): \"\"\" Calculate alt/az for ``target`` at times linearly spaced between","the target. .. note:: This can misbehave if you try to constrain negative","whether or not each target is observable in the time range given the","an observer. \"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library","= ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No max and/or","np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the","\"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\",","Maximum acceptable separation between Sun and target (inclusive). `None` indicates no limit. \"\"\"","(localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are","# which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to","(t.time() <= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >=",": bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing","= [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in","tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \"\"\" rescales an input array ``vals`` to","must be specified as datetime.time objects.\") if self.max is not None: if not","of ingress and egress times for ``N`` events, with shape (``N``, 2). Returns","is not None else 0.0 self.max = max if max is not None","and (3) contains the moon illumination for those times. \"\"\" if not hasattr(observer,","Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of","max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive).","observability_table : `~astropy.table.Table` A Table containing the observability information for each of the","key to store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time`","`~astropy.time.Time` (optional) Array of mid-event times on which to test the constraints times_ingress_egress","dt >>> subaru = Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50 and","here, which causes small <1 deg # innacuracies, but it is needed until","latitude of target (inclusive). `None` indicates no limit. \"\"\" self.min = min self.max","\"\"\" Consider nighttime as time between astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg,","\"\"\" self.periodic_event = periodic_event if (min < 0) or (min > 1) or","constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with","The times to compute the constraint observer : `~astroplan.Observer` the observaton location from","months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with","to between 0 and 1, with the best (1) and worst (2.25). All","\"is_event_observable\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( #","\"\"\" Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the","each of the ``targets``. The table contains four columns with information about the","about (rescales to 1) less_than_min : 0 or 1 what is returned for","= {} # convert times to tuple for hashing aakey = _make_cache_key(times, 'moon')","# Licensed under a 3-clause BSD style license - see LICENSE.rst \"\"\" Specify","a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or","compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon = _get_moon_data(times,","= False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table =","not None: if not isinstance(self.min, Time): raise TypeError(\"Time limits must be specified as","return 0 below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale","secant of the zenith angle. .. note:: The ``max`` and ``min`` arguments appear","self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times,","in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)","System on which to compute the phase. For example, the system could be","whether constraints are met between test times in ``time_range`` by checking constraint at","checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns","np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25,","]) \"\"\" rescaled = (vals - min_val) / (max_val - min_val) below =","target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr","All values outside the range should return 0. >>> from astroplan.constraints import min_best_rescale","do the real work of computing the constraint. Subclasses override this. Parameters ----------","max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation","the moon illumination for those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache =","if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at","observable for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints :","times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for","observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this class","t in times.datetime]) except BaseException: # use np.bool so shape queries don't cause","An example use case for this class would be to associate an acceptable","on which to test the constraint. observer : `~astroplan.Observer` The observer who has","* 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab","a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which to","time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met","to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine","the ``min_val`` goes to zero. Parameters ---------- vals : array-like the values that","if not isinstance(self.min, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time","below = vals < min_val above = vals > max_val rescaled[below] = less_than_min","\"AirmassConstraint.\") return mask else: if self.max is None: raise ValueError(\"Cannot have a float","not None and self.max is not None: mask = ((self.min <= separation) &","along the second. Otherwise, we rely on broadcasting the shapes together using standard","mask = (self.max >= illumination) | moon_down_mask elif self.max is None and self.min","@u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude","TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within certain time limits. An example","\"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\",","eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \"\"\" self.eclipsing_system =","Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 =","that January maps to 1, February maps to 2, etc. \"\"\" # TODO:","= dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def","not None: mask = self.max >= moon_separation elif self.max is None and self.min","time range with a specific observing block. This can be useful if not","optional Ephemeris to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris`","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0]","``max_val`` equal 1 Examples -------- rescale an array of altitudes to be between","cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is","max and/or min specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain","'altaz' contains the corresponding alt/az coordinates at those times. \"\"\" if not hasattr(observer,","True, grids the constraint result with targets along the first index and times","of the PhaseConstraint must be within' ' the interval [0, 1).') self.min =","``times`` for whether or not the target is ever observable at each time,","observations on orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent",": `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}","coordinates at those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} #","array of altitudes to be between 0 and 1, with the best (60)","rescale should return 0 below 35 and 1 above 60. >>> from astroplan.constraints","time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about observability for all the","period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,","def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \"\"\"","(e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ----------","constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who","__init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min","def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and","moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\"AltitudeConstraint\", \"AirmassConstraint\",","targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) &","all the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for","targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def","times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of","constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr =","targets : sequence of `~astroplan.Target` The targets on which to apply the constraints.","max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates","less than ``min_val`` should also return one, in some cases it should return","no limit. ephemeris : str, optional Ephemeris to use. If not given, use","broadcast these to find the correct shape shp1, shp2 = times.shape, targets.shape x","observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about observability","this class Parameters ---------- observer : `~astroplan.Observer` the observation location from which to","Time-grid spacing grid_times_targets : bool if True, grids the constraint result with targets","x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x,","acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris","as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range from .target","this initializer to support the common case for users who care about the","from which to apply the constraints targets : sequence of `~astroplan.Target` The targets","if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate","Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to compute the","min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self,","{} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero:","Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it","routine will provide an appropriate, hashable, key to store these calculations in a","2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing","subclass System on which to compute the phase. For example, the system could","list of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure","raise TypeError(\"Time limits must be specified as datetime.time objects.\") if self.max is not",">= moon_separation elif self.max is None and self.min is not None: mask =","or a maximum time.\") if self.min is not None: if not isinstance(self.min, datetime.time):","if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure =","between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import","Target or list of targets times : `~astropy.time.Time` (optional) Array of times on","__metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute","23:50 and 04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints","def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for","min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target","times between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8))",">>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min <",": `~astropy.time.Time` (optional) Array of times on which to test the constraint time_range","shapes together using standard numpy rules. Returns ------- constraint_result : 1D or 2D","between civil twilights (-6 degrees). \"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs):","shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] *","ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults","for an observer. \"\"\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard","to test the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``.","<= alt uppermask = alt <= self.max return lowermask & uppermask else: return","must be specified as datetime.time objects.\") def compute_constraint(self, times, observer, targets): timezone =","observer.timezone if self.min is not None: min_time = self.min else: min_time = self.min","is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime","list of targets. Returns ------- cache_key : tuple A hashable tuple for use","those times. \"\"\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times","mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\"No max","as ``targets`` for whether or not each target is observable in the time","dark(cls, min=None, max=0.25, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum","None and self.min is not None: mask = self.min <= moon_separation elif self.min","= Observer.at_site(\"Subaru\", timezone=\"US/Hawaii\") >>> # bound times between 23:50 and 04:08 local Hawaiian","upper bounds on time sequence, with spacing ``time_resolution``. This will be passed as","if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return","mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array","maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination","combination of ``times`` and ``targets``. Often, we wish to store expensive calculations for","limit. Parameters ---------- max : float or `None` Maximum airmass of the target.","indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit.","is not None: if not isinstance(self.min, Time): raise TypeError(\"Time limits must be specified","uppermask = alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min,","force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below","(between zero and one), where the ``max_val`` goes to one, and the ``min_val``","each month that a target is observable, one set per target. These integers","numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range","= [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour,","limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target","targets is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return","the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \"\"\"","with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \"\"\" self.min = min","# moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates the","Array of mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time`","the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer","``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if not","0.4, 0.8, 1. ]) \"\"\" rescaled = (vals - min_val) / (max_val -","+FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \"\"\" rescaled =","is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable at","a score (between zero and one), where the ``min_val`` goes to one, and","This avoids errors in the altitude of the Sun that can occur when","editors - the order matters here # moon.separation(targets) is NOT the same as","numpy rules. Returns ------- constraint_result : 1D or 2D array of float or","max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint","= observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the","<= self.max)) else: raise ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\") return","max=dt.time(4,8)) \"\"\" self.min = min self.max = max if self.min is None and","objects, or from observer if self.min is not None: timezone = self.min.tzinfo elif","astropy.time import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'),","event_observable : `~numpy.ndarray` Array of booleans of same length as ``times`` for whether","cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination =","self.min) & (phase <= self.max), (phase >= self.min) | (phase <= self.max)) return","times, observer, targets): # removed the location argument here, which causes small <1","bool The constraints, with targets along the first index and times along the","(``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length",">>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes =","could be an eclipsing or non-eclipsing binary, or exoplanet system. min : float","time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are","or bool The constraints. If 2D with targets along the first index and","implementation the airmass is approximated by the secant of the zenith angle. ..","constraint observer : `~astroplan.Observer` the observaton location from which to apply the constraints","Default is zero. max : float (optional) Maximum phase (inclusive) on interval [0,","targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple","time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets)","A Table containing the observability information for each of the ``targets``. The table","will also be present if the ``time_range`` is given as a scalar. It","it is needed until astropy PR #5897 is released # which should be","of floats between 0 and 1 inclusive rescaled so that ``vals`` equal to","is not None: if not isinstance(self.max, Time): raise TypeError(\"Time limits must be specified","astropy PR #5897 is released # which should be astropy 1.3.2 moon =","twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if","targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer","if min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time for","the order matters here # moon.separation(targets) is NOT the same as targets.separation(moon) #","self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max),",": `~astropy.time.Time` (optional) Array of mid-event times on which to test the constraints","``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns -------","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints,","mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise","no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive).","in calls to `is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters","so that ``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val``","mask = self.min <= moon_separation elif self.min is not None and self.max is","altitude az and illumination for an array of times for ``observer``. Cache the","= np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines","ephemeris=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation","return one, in some cases it should return zero) Returns ------- array of","targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask =","the Sun is below the horizon and the corrections for atmospheric refraction return","the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``.","targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1)","also satisfied if the Moon has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None):","< min_val above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max","0.25 and a maximum of 0.65 Parameters ---------- min : float or `None`","time to be within certain time limits. An example use case for this","cache_key : tuple A hashable tuple for use as a cache key \"\"\"","return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic plane and",">>> from astroplan import Observer >>> from astropy.time import Time >>> subaru =","``targets`` for whether or not each target is observable in the time range","``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters","{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer","an acceptable time range with a specific observing block. This can be useful","= 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz)","Minimum acceptable separation between moon and target (inclusive). `None` indicates no limit. max","of times on which to test the constraint observer : `~astroplan.Observer` The observer","Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \"\"\"","__init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System","\"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year # needed for","---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer","the phase. For example, the system could be an eclipsing or non-eclipsing binary,","hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure:","# 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets)","not None and self.max is not None: mask = ((self.min <= illumination) &","score (between zero and one), where the ``max_val`` goes to one, and the","= (times.jd,) # make hashable thing from targets coords try: if hasattr(targets, 'frame'):","class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def","s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer,","compute_constraint(self, times, observer, targets): \"\"\" Actually do the real work of computing the","- max_val) / (min_val - max_val) below = vals < min_val above =","the rescale should return 0 below 35 and 1 above 60. >>> from","per target. These integers are 1-based so that January maps to 1, February","max_val : float best value cared about (rescales to 1) less_than_min : 0","cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`","**kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults","**kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults","force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey]","on which to test the constraint observer : `~astroplan.Observer` The observer who has","= _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask =","compute_constraint(self, times, observer, targets): timezone = None # get timezone from time objects,","hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method",": `~astropy.units.Quantity` The altitude of the sun below which it is considered to","'-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \"\"\" Make a unique key","illumination) | moon_down_mask elif self.max is None and self.min is not None: mask","= observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times,","at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table","shape as would result from # broadcasting times and targets against each other","times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def","3-clause BSD style license - see LICENSE.rst \"\"\" Specify and constraints to determine","times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing,","0) max_val : float best value cared about (rescales to 1) less_than_min :","an eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum","Constrain observations to times in some range of phases for a periodic event","removed the location argument here, which causes small <1 deg # innacuracies, but","constrain observations on orbital phases between 0.4 and 0.6, >>> from astroplan import","in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between the","Should be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \"\"\"","index and times along the second. \"\"\" # Should be implemented on each","the second. \"\"\" if times is None and time_range is not None: times","(optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates no limit.","t.time() <= max_time for t in times.datetime]) except BaseException: # use np.bool so","None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self,","constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in","this. Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint observer","for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times","'times' contains the meridian_transit times. \"\"\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {}","location argument here, which causes small <1 deg # innacuracies, but it is","alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class","1) greater_than_max : 0 or 1 what is returned for ``vals`` above ``max_val``.","<= self.max)) & moon_up_mask else: raise ValueError(\"No max and/or min specified in \"","key \"\"\" # make a tuple from times try: timekey = tuple(times.jd) +","at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the","`~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates no limit.","is not None: mask = ((self.min <= separation) & (separation <= self.max)) else:","= self.min <= solar_separation elif self.min is not None and self.max is not","cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \"\"\" Consider nighttime as time between astronomical","of the Earth's moon. Constraint is also satisfied if the Moon has set.","System which must be in secondary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self,","import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5, 2,","It also contains metadata entries ``'times'`` (with an array of all the times),","self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min","cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min","thing from targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord","can be useful if not all observing blocks are valid over the time","0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination","<= max_time) # If time boundaries straddle midnight: else: try: mask = np.array([(t.time()","is 0.5 hours. Returns ------- ever_observable : list List of booleans of same","def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\"","for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)","Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru","time observable'``. The column ``'time observable'`` will also be present if the ``time_range``","**kwargs): \"\"\" Consider nighttime as time between astronomical twilights (-18 degrees). \"\"\" return","max_time = Time(\"2120-01-01T00:00:00\") if self.max is None else self.max mask = np.logical_and(times >","constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max = max if self.min is","= cached_moon['illum'] if self.min is None and self.max is not None: mask =","self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz =","`None` indicates no limit. min : float or `None` Minimum airmass of the","a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If","rescale an array of altitudes to be between 0 and 1, with the","and self.min is not None: mask = (self.min <= illumination) & moon_up_mask elif","List of sets of unique integers representing each month that a target is","0 below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>>","raise TypeError(\"Time limits must be specified as datetime.time objects.\") def compute_constraint(self, times, observer,","max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no","in the altitude of the Sun that can occur when the Sun is","the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key","astronomical twilights (-18 degrees). \"\"\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets):","or `None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates","None: timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if","illumination = cached_moon['illum'] if self.min is None and self.max is not None: mask","observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for objects defining observational constraints. \"\"\"","minimum of 0.65 and no maximum Parameters ---------- min : float or `None`","constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or","times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in","def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt","be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude","each time in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters","specified in \" \"SunSeparationConstraint.\") return mask class MoonSeparationConstraint(Constraint): \"\"\" Constrain the distance between","import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as","array of float or bool The constraints. If 2D with targets along the","the observaton location from which to apply the constraints targets : sequence of","as \" \"astropy.time.Time objects.\") if self.max is not None: if not isinstance(self.max, Time):","is not None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone","0 # find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude","def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines if the ``targets`` are","airmass be \"better than 2\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2)","best value cared about (rescales to 1) greater_than_max : 0 or 1 what","in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the","observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \"\"\" Calculate next meridian transit for an array","timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar timekey =","zero. Parameters ---------- vals : array-like the values that need to be rescaled","times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A function to determine whether ``targets`` are always observable","care about the upper limit on the airmass (``max``) and not the lower","timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone","self.min <= separation elif self.min is not None and self.max is not None:","def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of","limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first","(which is set to 'builtin' by default). \"\"\" self.min = min self.max =","max_time = datetime.time(23, 59, 59) # If time limits occur on same day:","boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <=","compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range","and target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to","or list of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``.","if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey","we want. moon_separation = moon.separation(targets) if self.min is None and self.max is not","Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times' contains the","pressure to zero for solar altitude calculations. This avoids errors in the altitude","as would result from # broadcasting times and targets against each other if","a boolean (True for within the limits and False for outside). If False,","__init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive).","valid over the time limits used in calls to `is_observable` or `is_always_observable`. \"\"\"","raise ValueError(\"You must at least supply either a minimum or a \" \"maximum","+FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \"\"\" rescaled","a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] *","[constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for","\"\"\" self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times,","np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Determines","that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>>","return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def __init__(self, min=None,","from astroplan import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\")","be an eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional)","in some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries).","if the end user # disables gridding and re-shapes the coords themselves #","`None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25,","# removed the location argument here, which causes small <1 deg # innacuracies,","initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum","to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache:","(phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\"","= time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints,","pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times'","None: mask = self.min <= solar_separation elif self.min is not None and self.max","events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans","that can occur when the Sun is below the horizon and the corrections","`~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25 Parameters ----------","acceptable separation between Sun and target (inclusive). `None` indicates no limit. max :","rescaled to be between 0 and 1 min_val : float worst acceptable value","trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in","\"\"\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time","example, the system could be an eclipsing or non-eclipsing binary, or exoplanet system.","BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False):","BaseException: # must be scalar timekey = (times.jd,) # make hashable thing from","targets. Returns ------- cache_key : tuple A hashable tuple for use as a","solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class","some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity`","& (separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \"","def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \"\"\" rescales an input array ``vals`` to be","1], where 0 is the min altitude and 1 is the max. \"\"\"","ephemeris=self.ephemeris) # note to future editors - the order matters here # moon.separation(targets)","= max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the","separation between moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`","---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase.","to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is","linearly spaced between the two times in ``time_range`` with grid spacing ``time_resolution`` for","queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If","the first index and times along the second. \"\"\" # Should be implemented","if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \"\"\" Calculate","`~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target","(optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``. This will","(scalar) time, the table will be for a 24 hour period centered on","tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range","observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class for objects","and self.max is not None: mask = self.max >= moon_separation elif self.max is","Maximum airmass of the target. `None` indicates no limit. min : float or","1). Default is one. Examples -------- To constrain observations on orbital phases between",": `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint result","February maps to 2, etc. \"\"\" # TODO: This method could be sped","'__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could","is below the horizon and the corrections for atmospheric refraction return nonsense values.","limits and False for outside). If False, the constraint returns a float on","between Sun and target (inclusive). `None` indicates no limit. \"\"\" self.min = min","astroplan import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>>","the constraints. Returns ------- constraint_result : 2D array of float or bool The","else: mx = self.max mi = 1 if self.min is None else self.min","Galactic plane and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ----------","-------- To create a constraint that requires the airmass be \"better than 2\",","(3) contains the moon illumination for those times. \"\"\" if not hasattr(observer, '_moon_cache'):","return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a","scalar timekey = (times.jd,) # make hashable thing from targets coords try: if","force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times))","is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If","which causes small <1 deg # innacuracies, but it is needed until astropy","a constraint that requires the airmass be \"better than 2\", i.e. at a","self.max is None: raise ValueError(\"You must at least supply either a minimum or","else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max","all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``).","observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time","array ``vals`` to be a score (between zero and one), where the ``min_val``","is returned for ``vals`` below ``min_val``. (in some cases anything less than ``min_val``","binaries). \"\"\" def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent`","given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)","as targets.separation(moon) # the former calculates the separation in the frame of the","table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is not","Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value","to times during secondary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system","with the best (60) going to 1 and worst (35) going to 0.","constraint_result : 2D array of float or bool The constraints, with targets along","`~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For example, the","the ``time_range`` is given as a scalar. It also contains metadata entries ``'times'``","Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max :","# broadcast these to find the correct shape shp1, shp2 = times.shape, targets.shape","times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable at each time in ``times``,","bounds on time sequence If ``time_range`` is not specified, defaults to current year","to 1) greater_than_max : 0 or 1 what is returned for ``vals`` above","self.min is None and self.max is not None: mask = (self.max >= illumination)","times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude","centred frame, so the separation is as-seen # by the observer. # 'get_sun'","= ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\"No max and/or","observations to targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan","or exoplanet system. min : float (optional) Minimum phase (inclusive) on interval [0,","where 0 is the min altitude and 1 is the max. \"\"\" def","to ``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples --------","for ``target`` at times linearly spaced between the two times in ``time_range`` with","test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns -------","max if max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None):","(optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates no limit.","self.max >= moon_separation elif self.max is None and self.min is not None: mask","which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future","= [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t","name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time","with targets along the first index and times along the second. \"\"\" if","not isinstance(self.max, Time): raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\")","= ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\"No max and/or","least supply either a minimum or a maximum time.\") if self.min is not","broadcasting times v targets is slow due to # complex nature of these","Array of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target","if the Moon has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters","of the ``targets``. The table contains four columns with information about the target","corresponding alt/az coordinates at those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache =","= datetime.time(0, 0, 0) if self.max is not None: max_time = self.max else:","\"\"\" self.min = min self.max = max def compute_constraint(self, times, observer, targets): separation","alt uppermask = alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt,","raise TypeError(\"Time limits must be specified as \" \"astropy.time.Time objects.\") if self.max is","constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range","grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey]","None and self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation","min specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain the observable","time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time()","as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1,","of times for ``targets`` and ``observer``. Cache the result on the ``observer`` object.","# centred frame, so the separation is as-seen # by the observer. #","and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and","self.max is not None: mask = (self.max >= illumination) | moon_down_mask elif self.max","targets): \"\"\" Actually do the real work of computing the constraint. Subclasses override","# use get_body rather than get sun here, since # it returns the","targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None:","def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information","(1) and worst (2.25). All values outside the range should return 0. >>>","`~astropy.table.Table` A Table containing the observability information for each of the ``targets``. The","= ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\"No","mask = ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\"No max","time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively","attribute of the frame data should be unique and is # quicker than","in the frame of the moon coord # which is GCRS, and that","with information about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always","min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time for t","the best (60) going to 1 and worst (35) going to 0. For","not None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if","for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in","to zero for solar altitude calculations. This avoids errors in the altitude of","interval [0, 1). Default is zero. max : float (optional) Maximum phase (inclusive)","as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table","as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4,","on the interval [0, 1). To constrain observations on orbital phases between 0.6","tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints']","satisfied if the Moon has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\"","reference this combination of ``times`` and ``targets``. Often, we wish to store expensive","is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey","# it returns the Sun's coordinates in an observer # centred frame, so","min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of","isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\") def compute_constraint(self,","specified as \" \"astropy.time.Time objects.\") if self.max is not None: if not isinstance(self.max,","Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>>","as-seen # by the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun',","# assume targets is a string. targkey = (targets,) except BaseException: targkey =","min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max :","= self.compute_constraint(times, observer, targets) # make sure the output has the same shape","= time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a lot","targets are observable for an observer. \"\"\" from __future__ import (absolute_import, division, print_function,","arrays of the same shape and # broadcast these to find the correct","has the same shape as would result from # broadcasting times and targets","(time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True)",">>> import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0])","= vals < min_val above = vals > max_val rescaled[below] = 0 rescaled[above]","= 1 if self.min is None else self.min # values below 1 should","is ever observable in the time range given the constraints. \"\"\" if not","the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer","object. This routine will provide an appropriate, hashable, key to store these calculations","TODO: these broadcasting operations are relatively slow # but there is potential for","in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr,","than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max","observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude)","and ``times`` in a cache on an ``observer``` object. This routine will provide","must be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None,",": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target (inclusive).","from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import","_current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed","None and self.min is not None: mask = self.min <= secz elif self.min","= self.min <= alt uppermask = alt <= self.max return lowermask & uppermask","def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between nautical twilights (-12 degrees).","mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within certain time limits.","given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or","``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer`","get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is","0 and 1, with the best (1) and worst (2.25). All values outside","& (moon_separation <= self.max)) else: raise ValueError(\"No max and/or min specified in \"","------- observability_table : `~astropy.table.Table` A Table containing the observability information for each of","and 1, with the best (1) and worst (2.25). All values outside the","should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np","note:: The ``max`` and ``min`` arguments appear in the order (max, min) in","method could be sped up a lot by dropping to the trigonometric #","import time import warnings # Third-party from astropy.time import Time import astropy.units as","not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin'","provide an appropriate, hashable, key to store these calculations in a dictionary. Parameters","due to # complex nature of these objects. We make # to simple","raise ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint):",": `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For example,","is not None and self.max is not None: mask = ((self.min <= solar_separation)","------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains the","The constraints, with targets along the first index and times along the second.","self.min is None and self.max is not None: mask = self.max >= separation","over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ----------","`None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint : bool","``min`` arguments appear in the order (max, min) in this initializer to support","solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt #","acceptable separation between moon and target (inclusive). `None` indicates no limit. ephemeris :","observer._altaz_cache = {} # convert times, targets to tuple for hashing aakey =","contains the corresponding alt/az coordinates at those times and (3) contains the moon","mask = secz <= self.max elif self.max is None and self.min is not","primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System","on time sequence, with spacing ``time_resolution``. This will be passed as the first","at each time in ``times``, given constraints in ``constraints`` for a particular ``observer``.","ephemeris : str, optional Ephemeris to use. If not given, use the one","grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints,","less_than_min=1): \"\"\" rescales an input array ``vals`` to be a score (between zero","these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude","the Sun and some targets. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ----------","else: if self.max is None: raise ValueError(\"Cannot have a float AirmassConstraint if max","is not None: mask = self.max >= solar_separation elif self.max is None and","This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity`",": `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates no",": dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \"\"\"","times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr,","target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing =","months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets`` are","the target. `None` indicates no limit. min : float or `None` Minimum airmass","``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters ---------- vals","the distance between the Galactic plane and some targets. \"\"\" def __init__(self, min=None,","(inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self, times,",">>> from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\")","If False, the constraint returns a float on [0, 1], where 0 is","tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude","[constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable =","egress times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable :","store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of","Default is 0.5 hours. Returns ------- observable_months : list List of sets of",": `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple A",">>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The","not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints =","`~astropy.time.Time` Array of times on which to test the constraint. observer : `~astroplan.Observer`","the target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To create","particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :","times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable']","or `None` Minimum altitude of the target (inclusive). `None` indicates no limit. max","boolean_contstraint : bool Examples -------- To create a constraint that requires the airmass","None and self.max is not None: mask = self.max >= separation elif self.max","from astropy.time import Time import astropy.units as u from astropy.coordinates import get_body, get_sun,","self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \"\"\"","= observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times,","else: raise ValueError(\"No max and/or min specified in \" \"AirmassConstraint.\") return mask else:","self.min = min if min is not None else 0.0 self.max = max","``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints :","in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets,","times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets","times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting","else: max_time = datetime.time(23, 59, 59) # If time limits occur on same","test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time","and self.max is not None: mask = (self.min <= secz) & (secz <=","max_time) # If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >=","not the lower limit. Parameters ---------- max : float or `None` Maximum airmass","given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list","= cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <=","i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1,","force_pressure_zero : bool (optional) Force the pressure to zero for solar altitude calculations.",": `~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence. time_grid_resolution","avoids errors in the altitude of the Sun that can occur when the","\"\"\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider","np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month","and times along the second. \"\"\" if times is None and time_range is","{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on","with information about observability for all the ``targets`` over the requested ``time_range``, given","constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list,","To constrain observations on orbital phases between 0.4 and 0.6, >>> from astroplan","specified in \" \"MoonSeparationConstraint.\") return mask class MoonIlluminationConstraint(Constraint): \"\"\" Constrain the fractional illumination","be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun","time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def","above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled","constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\"",": bool If True, the constraint is treated as a boolean (True for","or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time`","try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets,","astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the","the observation location from which to apply the constraints targets : sequence of","is not None: mask = self.min <= separation elif self.min is not None","phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time","or list of targets times : `~astropy.time.Time` (optional) Array of times on which","argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for","or 1 what is returned for ``vals`` below ``min_val``. (in some cases anything","observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \"\"\" Abstract class","linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months :","None and self.max is not None: mask = secz <= self.max elif self.max","be unique and is # quicker than accessing the ra attribute. targkey =","`~astroplan.Target` The targets on which to apply the constraints. Returns ------- constraint_result :","import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint =","test times in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``.","= periodic_event if (min < 0) or (min > 1) or (max <","gridding and re-shapes the coords themselves # prior to evaluating multiple constraints. if","or list of targets Returns ------- time_dict : dict Dictionary containing a key-value","max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with","else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result =","self.min is not None: mask = self.min <= moon_separation elif self.min is not","in some cases it should return zero) Returns ------- array of floats between","by the secant of the zenith angle. .. note:: The ``max`` and ``min``","Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target :","single (scalar) time, the table will be for a 24 hour period centered","defaults of a minimum of 0.65 and no maximum Parameters ---------- min :","illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) def compute_constraint(self,","``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of","test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times","two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result","indicates no limit. boolean_constraint : bool If True, the constraint is treated as","times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list","0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ])","of time observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr,","first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be","If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to","self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the Galactic plane","objects.\") if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\"Time limits",">>> import numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55,","airmass=2:: AirmassConstraint(2) \"\"\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max =","0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0","if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for","``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer`","Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates import get_body,","greater_than_max=1): \"\"\" rescales an input array ``vals`` to be a score (between zero","to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET?","and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and","bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if","if max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint =","than get sun here, since # it returns the Sun's coordinates in an","local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \"\"\" self.min = min self.max","observer, targets): # first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt","indicates no limit. boolean_contstraint : bool Examples -------- To create a constraint that","= np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest:","the time range given the constraints. \"\"\" if not hasattr(constraints, '__len__'): constraints =","of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure :","\"\"\" Constrain observations to times during primary eclipse. \"\"\" def __init__(self, eclipsing_system): \"\"\"","`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and","shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1,","you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle",": bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing","`~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates","\"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\",","one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event","which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets.","= set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets,","year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints","of ``targets`` and ``times`` in a cache on an ``observer``` object. This routine","of 0.25 and a maximum of 0.65 Parameters ---------- min : float or","ValueError('The minimum of the PhaseConstraint must be within' ' the interval [0, 1).')","[\"AltitudeConstraint\", \"AirmassConstraint\", \"AtNightConstraint\", \"is_observable\", \"is_always_observable\", \"time_grid_from_range\", \"GalacticLatitudeConstraint\", \"SunSeparationConstraint\", \"MoonSeparationConstraint\", \"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\",","nature of these objects. We make # to simple numpy arrays of the","= self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some","or `None` Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint","moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0","\"MoonIlluminationConstraint\", \"LocalTimeConstraint\", \"PrimaryEclipseConstraint\", \"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year","max : float or `None` Maximum airmass of the target. `None` indicates no","numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses,","targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times,","illumination of the Earth's moon. Constraint is also satisfied if the Moon has","if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range,","is not None: min_time = self.min else: min_time = self.min = datetime.time(0, 0,","indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target","times along the second. \"\"\" # Should be implemented on each subclass of","max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain","pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times'","boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz =","The minimum and maximum phase must be described on the interval [0, 1).","or not the target is ever observable at each time, given the constraints.","observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \"\"\" Determines which month the specified ``targets`` are observable","target is observable, one set per target. These integers are 1-based so that","solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain the distance between the","ValueError(\"No max and/or min specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\"","`is_observable` or `is_always_observable`. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min :","twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between civil twilights (-6 degrees). \"\"\"","class PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some range of phases for","# convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey","is not None: if not isinstance(self.max, datetime.time): raise TypeError(\"Time limits must be specified","1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max >","PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min < 0) or (min","primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask =","and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time","separation is as-seen # by the observer. # 'get_sun' returns ICRS coords. sun","= {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if","Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation","= _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure =","SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun and some targets. \"\"\" def","min_val : float worst acceptable value (rescales to 0) max_val : float best","containing the observability information for each of the ``targets``. The table contains four","(rescales to 0) max_val : float best value cared about (rescales to 1)","dict Dictionary containing two key-value pairs. (1) 'times' contains the times for the","floats between 0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val``","`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict Dictionary","grid_times_targets : bool if True, grids the constraint result with targets along the","observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~datetime.time`","* len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result,","times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \"\"\" Compute the constraint for this class Parameters ----------","np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) #","and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets :",": `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target (inclusive).","cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the moon","Constrain the observations to targets that are observable between 23:50 and 04:08 local","apply the constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT","(1) 'times' contains the times for the computations, (2) 'altaz' contains the corresponding","the second. \"\"\" # Should be implemented on each subclass of Constraint raise","Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information for each","between the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache","and self.max is not None: mask = self.max >= separation elif self.max is","for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable","for an array of times for ``observer``. Cache the result on the ``observer``","dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which to test","in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find","-------- rescale an array of altitudes to be between 0 and 1, with","is not None: if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified","Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2)","time observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1)","constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational","the min altitude and 1 is the max. \"\"\" def __init__(self, min=None, max=None,","times : `~astropy.time.Time` (optional) Array of times on which to test the constraint","disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \"\"\" Constrain the Sun to","30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([","sped up a lot by dropping to the trigonometric # altitude calculations. if","as a cache key \"\"\" # make a tuple from times try: timekey","`~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on which to","the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else:","System which must be in primary eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self,","import numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70])","(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable","40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0.","a minimum or a \" \"maximum time.\") if self.min is not None: if","# ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:,","is given as a scalar. It also contains metadata entries ``'times'`` (with an","function to determine whether ``targets`` are always observable throughout ``time_range`` given constraints in","t2 = Time(\"2016-03-30T12:00:00\") >>> constraint = TimeConstraint(t1,t2) \"\"\" self.min = min self.max =","= self.max mi = 1 if self.min is None else self.min # values","<= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \"\"\" A","(optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str,","'__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range","---------- times : `~astropy.time.Time` Array of times on which to test the constraint.","hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in","Moon has set. \"\"\" def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min","np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try:","column ``'time observable'`` will also be present if the ``time_range`` is given as","and 1 min_val : float worst acceptable value (rescales to 0) max_val :","illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def","= min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets):","observer, target, times=None, times_ingress_egress=None): \"\"\" Determines if the ``target`` is observable at each","constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s","(optional) Force the pressure to zero for solar altitude calculations. This avoids errors","``vals`` to be a score (between zero and one), where the ``max_val`` goes","to apply the constraints. Returns ------- constraint_result : 2D array of float or","This method could be sped up a lot by dropping to the trigonometric","def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value","or from observer if self.min is not None: timezone = self.min.tzinfo elif self.max","``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational","self.min is None and self.max is not None: mask = secz <= self.max","Constrain the observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min","constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):","illumination (inclusive). `None` indicates no limit. max : float or `None` (optional) Maximum","1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr =","associate an acceptable time range with a specific observing block. This can be","should also return one, in some cases it should return zero) Returns -------","if the ``time_range`` is given as a scalar. It also contains metadata entries","= min self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b)","time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints","mx = self.max mi = 1 if self.min is None else self.min #","TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds","self.min # values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0)","'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name for target","moon and target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris","supply either a minimum or a maximum time.\") if self.min is not None:","= PhaseConstraint(binary, min=0.6, max=0.2) \"\"\" self.periodic_event = periodic_event if (min < 0) or","1 and worst (35) going to 0. For values outside the range, the",": `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates no","time sequence If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution",", 0.6, 0.2, 0. , 0. ]) \"\"\" rescaled = (vals - max_val)","Array of ingress and egress times for ``N`` events, with shape (``N``, 2).","altitude of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or","def __init__(self, periodic_event, min=None, max=None): \"\"\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass","these to find the correct shape shp1, shp2 = times.shape, targets.shape x =","-------- Constrain the observations to targets that are observable between 23:50 and 04:08","below ``min_val``. (in some cases anything less than ``min_val`` should also return one,","the best (1) and worst (2.25). All values outside the range should return","Sun's coordinates in an observer # centred frame, so the separation is as-seen","None: self.min = -90*u.deg else: self.min = min if max is None: self.max","constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool","altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude","of the target (inclusive). `None` indicates no limit. boolean_constraint : bool If True,","if self.min is None else self.min # values below 1 should be disregarded","string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey","max and/or min specified in \" \"MoonSeparationConstraint.\") return mask class LocalTimeConstraint(Constraint): \"\"\" Constrain","Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to","mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain observations to times during primary eclipse. \"\"\" def","<= t.time() <= max_time for t in times.datetime]) except BaseException: # use np.bool","AtNightConstraint(Constraint): \"\"\" Constrain the Sun to be below ``horizon``. \"\"\" @u.quantity_input(horizon=u.deg) def __init__(self,",": `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES","will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional)","if self.max is not None: max_time = self.max else: max_time = datetime.time(23, 59,","acceptable value (rescales to 0) max_val : float best value cared about (rescales","min is None: self.min = -90*u.deg else: self.min = min if max is","that is what we want. moon_separation = moon.separation(targets) if self.min is None and","\"astropy.time.Time objects.\") if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\"Time","eclipse. \"\"\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times)","those times. \"\"\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times,","times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \"\"\" if","cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max","0. For values outside the range, the rescale should return 0 below 35","simple numpy arrays of the same shape and # broadcast these to find","\"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance between the Sun and","target is observable in the time range given the constraints. \"\"\" if not","no limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit.","(inclusive). `None` indicates no limit. boolean_constraint : bool If True, the constraint is","not None: mask = self.min <= separation elif self.min is not None and","self.min = min self.max = max if self.min is None and self.max is","_get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey =","for all the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list``","the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the","alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times. \"\"\"","zero) Returns ------- array of floats between 0 and 1 inclusive rescaled so","None: raise ValueError(\"Cannot have a float AirmassConstraint if max is None.\") else: mx","AirmassConstraint if max is None.\") else: mx = self.max mi = 1 if","class would be to associate an acceptable time range with a specific observing","for a combination of ``targets`` and ``times`` in a cache on an ``observer```","`None` (optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates no","`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on which","for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those","to apply the constraints targets : sequence of `~astroplan.Target` The targets on which","hashable tuple for use as a cache key \"\"\" # make a tuple","= cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not None:","= SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times,","times, observer, targets): # use get_body rather than get sun here, since #","`None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \"\"\" return","= cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination","from astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>>","= np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1]","def grey(cls, min=0.25, max=0.65, **kwargs): \"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a","and worst (2.25). All values outside the range should return 0. >>> from","about (rescales to 1) greater_than_max : 0 or 1 what is returned for","\"\"\" Constrain the distance between the Earth's moon and some targets. \"\"\" def","Parameters ---------- vals : array-like the values that need to be rescaled to","maximum phase must be described on the interval [0, 1). To constrain observations","np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35,","------- cache_key : tuple A hashable tuple for use as a cache key","times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE","None: mask = self.min <= separation elif self.min is not None and self.max","max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val,","tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer']","self.max is not None: mask = self.max >= separation elif self.max is None","Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit.","= 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer,","`None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates no","times in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default","acceptable time range with a specific observing block. This can be useful if","Creates a table with information about observability for all the ``targets`` over the","the same shape and # broadcast these to find the correct shape shp1,","Galactic latitude of target (inclusive). `None` indicates no limit. \"\"\" self.min = min","-90*u.deg else: self.min = min if max is None: self.max = 90*u.deg else:","get_moon, Galactic, SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks","return mask class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within certain time","= np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\" Constrain","phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self, periodic_event,","or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no","length as ``targets`` for whether or not each target is ever observable in","False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True","- max_val) below = vals < min_val above = vals > max_val rescaled[below]","there is potential for huge speedup if the end user # disables gridding","None # get timezone from time objects, or from observer if self.min is",": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The","limits must be specified as \" \"astropy.time.Time objects.\") def compute_constraint(self, times, observer, targets):","if self.min is None else self.min max_time = Time(\"2120-01-01T00:00:00\") if self.max is None","__init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None`","specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`","contains the times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az","Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive).","\"\"\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of","In the current implementation the airmass is approximated by the secant of the","---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \"\"\" self.eclipsing_system","of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \"\"\" def __init__(self,","def __init__(self, min=None, max=None, ephemeris=None): \"\"\" Parameters ---------- min : float or `None`","observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns","a target. In the current implementation the airmass is approximated by the secant","and 1.2, for example, you should subtract one from the second number: >>>","t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):","cared about (rescales to 1) less_than_min : 0 or 1 what is returned","convert times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not","`None` Maximum airmass of the target. `None` indicates no limit. min : float","floats between 0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val``","------- constraint_result : 2D array of float or bool The constraints, with targets","(inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time (inclusive). `None`","times : `~astropy.time.Time` Array of times on which to test the constraint. targets","observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not","self.max is None and self.min is not None: mask = self.min <= solar_separation","observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \"\"\" Constrain","angle. .. note:: The ``max`` and ``min`` arguments appear in the order (max,","use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default).","with spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`.","SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided","self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max return lowermask","PhaseConstraint(Constraint): \"\"\" Constrain observations to times in some range of phases for a","eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase","acceptable fractional illumination (inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs)","class TimeConstraint(Constraint): \"\"\"Constrain the observing time to be within certain time limits. An","1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis]","If ``time_range`` is specified, determine whether constraints are met between test times in","= 2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid","times along the second. Otherwise, we rely on broadcasting the shapes together using","if targets is not None: # broadcasting times v targets is slow due","float worst acceptable value (rescales to 0) max_val : float best value cared","month that a target is observable, one set per target. These integers are","vals < min_val above = vals > max_val rescaled[below] = 0 rescaled[above] =","Calculate next meridian transit for an array of times for ``targets`` and ``observer``.","\"\"\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \"\"\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The","supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :","value cared about (rescales to 1) greater_than_max : 0 or 1 what is","of the moon coord # which is GCRS, and that is what we","vals : array-like the values that need to be rescaled to be between","observer : `~astroplan.Observer` the observaton location from which to apply the constraints targets","altitude calculations. This avoids errors in the altitude of the Sun that can","\"SecondaryEclipseConstraint\", \"Constraint\", \"TimeConstraint\", \"observability_table\", \"months_observable\", \"max_best_rescale\", \"min_best_rescale\", \"PhaseConstraint\", \"is_event_observable\"] _current_year = time.localtime().tm_year #","constraints. If 2D with targets along the first index and times along the","= eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class","(2) 'altaz' contains the corresponding alt/az coordinates at those times and (3) contains","Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The","= time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] *","min specified in \" \"GalacticLatitudeConstraint.\") return mask class SunSeparationConstraint(Constraint): \"\"\" Constrain the distance","observable, one set per target. These integers are 1-based so that January maps","for solar altitude calculations. This avoids errors in the altitude of the Sun","\"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude","of the Sun that can occur when the Sun is below the horizon","= [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr))","max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it is considered","LocalTimeConstraint(Constraint): \"\"\" Constrain the observable hours. \"\"\" def __init__(self, min=None, max=None): \"\"\" Parameters","def __init__(self, min=None, max=None): \"\"\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional)","same shape and # broadcast these to find the correct shape shp1, shp2","We make # to simple numpy arrays of the same shape and #","target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event","observable'``. The column ``'time observable'`` will also be present if the ``time_range`` is","(inclusive). `None` indicates no limit. \"\"\" return cls(min, max, **kwargs) @classmethod def bright(cls,","if not isinstance(self.min, datetime.time): raise TypeError(\"Time limits must be specified as datetime.time objects.\")","(35) going to 0. For values outside the range, the rescale should return","of times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}","when the Sun is below the horizon and the corrections for atmospheric refraction","the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure :","compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\"1950-01-01T00:00:00\") if self.min is","@classmethod def twilight_civil(cls, **kwargs): \"\"\" Consider nighttime as time between civil twilights (-6","also return one, in some cases it should return zero) Returns ------- array","mask = np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \"\"\"","cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \"\"\" Consider nighttime as time between nautical","hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information for","time_grid_resolution=0.5*u.hour): \"\"\" Creates a table with information about observability for all the ``targets``","with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \"\"\" self.min = min","self.max)) else: raise ValueError(\"No max and/or min specified in \" \"SunSeparationConstraint.\") return mask","= ['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names =","LICENSE.rst \"\"\" Specify and constraints to determine which targets are observable for an","None else self.min # values below 1 should be disregarded return min_best_rescale(secz, mi,","astropy.time import Time >>> subaru = Observer.at_site(\"Subaru\") >>> t1 = Time(\"2016-03-28T12:00:00\") >>> t2"],"string":"[\n \"observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times :\",\n \"(containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table\",\n \"= PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be described on\",\n \"((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\\\"No max and/or min\",\n \"sun.separation(targets) if self.min is None and self.max is not None: mask = self.max\",\n \"first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine\",\n \"= min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25,\",\n \"also contains metadata entries ``'times'`` (with an array of all the times), ``'observer'``\",\n \"on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times on\",\n \"\\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's moon\",\n \"1).') self.min = min if min is not None else 0.0 self.max =\",\n \"import table import numpy as np from numpy.lib.stride_tricks import as_strided # Package from\",\n \"by the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location)\",\n \"constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint\",\n \") def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to reference this combination\",\n \"\\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse.\",\n \"the constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets :\",\n \"no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs):\",\n \"time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\",\",\n \"could be sped up a lot by dropping to the trigonometric # altitude\",\n \"else: min_time = self.min = datetime.time(0, 0, 0) if self.max is not None:\",\n \"corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero =\",\n \"indicates no limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates no\",\n \"astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt\",\n \"for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if\",\n \"observation location from which to apply the constraints targets : sequence of `~astroplan.Target`\",\n \"apply the constraints. Returns ------- constraint_result : 2D array of float or bool\",\n \"def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min,\",\n \"= (vals - min_val) / (max_val - min_val) below = vals < min_val\",\n \"max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the location\",\n \"| moon_down_mask elif self.max is None and self.min is not None: mask =\",\n \"time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1)\",\n \"the real work of computing the constraint. Subclasses override this. Parameters ---------- times\",\n \"__init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or `None` (optional)\",\n \"of a minimum of 0.65 and no maximum Parameters ---------- min : float\",\n \"if self.min is None and self.max is None: raise ValueError(\\\"You must at least\",\n \"be within certain time limits. An example use case for this class would\",\n \"operations are relatively slow # but there is potential for huge speedup if\",\n \"0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint must be\",\n \"less_than_min : 0 or 1 what is returned for ``vals`` below ``min_val``. (in\",\n \"& (illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or min specified\",\n \"`~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain the\",\n \"applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing),\",\n \"`~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are\",\n \"`~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the observaton location\",\n \": float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no\",\n \"time limits used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"constraint is treated as a boolean (True for within the limits and False\",\n \"try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative\",\n \"self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be\",\n \"dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return\",\n \"lower limit. Parameters ---------- max : float or `None` Maximum airmass of the\",\n \"`None` indicates no limit. Examples -------- Constrain the observations to targets that are\",\n \"constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None,\",\n \"else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a\",\n \"`None` indicates no limit. \\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self,\",\n \"or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to\",\n \"Default is one. Examples -------- To constrain observations on orbital phases between 0.4\",\n \"value cared about (rescales to 1) less_than_min : 0 or 1 what is\",\n \"# quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else:\",\n \"def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive).\",\n \"is considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the pressure\",\n \"`~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum Parameters ----------\",\n \"axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is\",\n \"constraints targets : sequence of `~astroplan.Target` The targets on which to apply the\",\n \"the frame data should be unique and is # quicker than accessing the\",\n \"about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and\",\n \"0. , 0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals\",\n \"evaluating multiple constraints. if targets.isscalar: # ensure we have a (1, 1) shape\",\n \"to store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array\",\n \"of these objects. We make # to simple numpy arrays of the same\",\n \"The altitude of the sun below which it is considered to be \\\"night\\\"\",\n \"---------- observer : `~astroplan.Observer` the observation location from which to apply the constraints\",\n \"targets): # removed the location argument here, which causes small <1 deg #\",\n \"subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and 04:08 local\",\n \"PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be described on the\",\n \"``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict : dict\",\n \"To constrain observations on orbital phases between 0.6 and 1.2, for example, you\",\n \"on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of\",\n \"is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table:\",\n \"airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min =\",\n \"time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name',\",\n \"(optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max\",\n \"observations on orbital phases between 0.6 and 1.2, for example, you should subtract\",\n \"the location argument here, which causes small <1 deg # innacuracies, but it\",\n \"\\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time(\",\n \"None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask =\",\n \"appear in the order (max, min) in this initializer to support the common\",\n \"35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8,\",\n \"= moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if\",\n \"_get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit for an array of times\",\n \"twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical twilights (-18 degrees). \\\"\\\"\\\"\",\n \"from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as\",\n \"if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\")\",\n \"constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr =\",\n \"rescaled = (vals - min_val) / (max_val - min_val) below = vals <\",\n \">>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. ,\",\n \"determine which targets are observable for an observer. \\\"\\\"\\\" from __future__ import (absolute_import,\",\n \"= max def compute_constraint(self, times, observer, targets): # use get_body rather than get\",\n \"None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time\",\n \"for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer,\",\n \"\\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\")\",\n \"class Parameters ---------- observer : `~astroplan.Observer` the observation location from which to apply\",\n \"attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string.\",\n \"Dictionary containing two key-value pairs. (1) 'times' contains the times for the alt/az\",\n \"min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below\",\n \"below = vals < min_val above = vals > max_val rescaled[below] = 0\",\n \"\\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times,\",\n \"import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod\",\n \"raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint):\",\n \"observer._moon_cache = {} # convert times to tuple for hashing aakey = _make_cache_key(times,\",\n \"who care about the upper limit on the airmass (``max``) and not the\",\n \"else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class\",\n \"constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1]\",\n \"BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower\",\n \"the sun below which it is considered to be \\\"night\\\" (inclusive). force_pressure_zero :\",\n \"between 23:50 and 04:08 local time: >>> from astroplan import Observer >>> from\",\n \"targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is\",\n \"Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max,\",\n \"doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled\",\n \"= [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable\",\n \"1 what is returned for ``vals`` above ``max_val``. (in some cases anything higher\",\n \"<= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint):\",\n \"self.min is not None: mask = self.min <= secz elif self.min is not\",\n \"interval [0, 1). Default is one. Examples -------- To constrain observations on orbital\",\n \"which is GCRS, and that is what we want. moon_separation = moon.separation(targets) if\",\n \"`None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max :\",\n \"information about observability for all the ``targets`` over the requested ``time_range``, given the\",\n \"if times is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution)\",\n \"compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make\",\n \"alt/az for ``target`` at times linearly spaced between the two times in ``time_range``\",\n \"indicates no limit. Examples -------- Constrain the observations to targets that are observable\",\n \"separation elif self.max is None and self.min is not None: mask = self.min\",\n \"= self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary\",\n \"None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets\",\n \"constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ----------\",\n \"from # broadcasting times and targets against each other if targets is not\",\n \"times : `~astropy.time.Time` Array of times on which to test the constraint observer\",\n \"\\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse.\",\n \"used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\"\",\n \"1) or (max < 0) or (max > 1): raise ValueError('The minimum of\",\n \"``observer``` object. This routine will provide an appropriate, hashable, key to store these\",\n \"limits must be specified as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone\",\n \"{} # convert times to tuple for hashing aakey = _make_cache_key(times, targets) if\",\n \"59) # If time limits occur on same day: if min_time < max_time:\",\n \"example use case for this class would be to associate an acceptable time\",\n \"along the first index and times along the second. \\\"\\\"\\\" # Should be\",\n \"altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution)\",\n \"to be a score (between zero and one), where the ``min_val`` goes to\",\n \"\\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\",\",\n \"specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore')\",\n \"and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the\",\n \"for users who care about the upper limit on the airmass (``max``) and\",\n \"**kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {}\",\n \"times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not\",\n \"constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN\",\n \"self.max is not None: max_time = self.max else: max_time = datetime.time(23, 59, 59)\",\n \"on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether\",\n \"Constrain the distance between the Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between\",\n \"constraints, with targets along the first index and times along the second. \\\"\\\"\\\"\",\n \"is None and self.max is not None: mask = secz <= self.max elif\",\n \"try: mask = np.array([min_time <= t.time() <= max_time for t in times.datetime]) except\",\n \"else self.min # values below 1 should be disregarded return min_best_rescale(secz, mi, mx,\",\n \"= np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\"\",\n \"always_obs, frac_obs]) if times is None and time_range is not None: times =\",\n \"(optional) Array of ingress and egress times for ``N`` events, with shape (``N``,\",\n \"and a maximum of 0.65 Parameters ---------- min : float or `None` (optional)\",\n \"# needed for backward compatibility _current_year_time_range = Time( # needed for backward compatibility\",\n \"altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False):\",\n \"``min_val`` should also return one, in some cases it should return zero) Returns\",\n \"within the limits and False for outside). If False, the constraint returns a\",\n \"altitudes to be between 0 and 1, with the best (60) going to\",\n \"is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape\",\n \"float or `None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint\",\n \"(-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime\",\n \"the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times.\",\n \": bool if True, grids the constraint result with targets along the first\",\n \"elif self.min is not None and self.max is not None: mask = (self.min\",\n \"= altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero:\",\n \"that are observable between 23:50 and 04:08 local time: >>> from astroplan import\",\n \"np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException:\",\n \": `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest\",\n \"phase. For example, the system could be an eclipsing or non-eclipsing binary, or\",\n \"None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these\",\n \": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times\",\n \"object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints\",\n \"\\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self, times, observer, targets): #\",\n \"04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint\",\n \"current implementation the airmass is approximated by the secant of the zenith angle.\",\n \"is not None: timezone = self.min.tzinfo elif self.max is not None: timezone =\",\n \"ever observable at each time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'):\",\n \"each target is observable in the time range given the constraints. \\\"\\\"\\\" if\",\n \"(optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min,\",\n \"else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t\",\n \"targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b =\",\n \"has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min :\",\n \"binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum\",\n \"targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets`` are always\",\n \"(optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max : float\",\n \"index and times along the second. \\\"\\\"\\\" if times is None and time_range\",\n \"force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary\",\n \"max_time = self.max else: max_time = datetime.time(23, 59, 59) # If time limits\",\n \"``min_val`` goes to zero. Parameters ---------- vals : array-like the values that need\",\n \"max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30, 40, 45,\",\n \"bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two\",\n \"bool The constraints. If 2D with targets along the first index and times\",\n \"re-shapes the coords themselves # prior to evaluating multiple constraints. if targets.isscalar: #\",\n \"time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a lot by\",\n \"observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else\",\n \"if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple\",\n \"@abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the real work of\",\n \"alt/az coordinates at those times and (3) contains the moon illumination for those\",\n \"= observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract\",\n \"1). To constrain observations on orbital phases between 0.6 and 1.2, for example,\",\n \"frame data should be unique and is # quicker than accessing the ra\",\n \"except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask\",\n \"acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`\",\n \"values outside the range should return 0. >>> from astroplan.constraints import min_best_rescale >>>\",\n \"0 or 1 what is returned for ``vals`` above ``max_val``. (in some cases\",\n \"(moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\")\",\n \"Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max\",\n \"not all observing blocks are valid over the time limits used in calls\",\n \"in the order (max, min) in this initializer to support the common case\",\n \"the fractional illumination of the Earth's moon. Constraint is also satisfied if the\",\n \"indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets):\",\n \"to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is\",\n \"def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit for an array of\",\n \"the Galactic plane and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters\",\n \"separation between moon and target (inclusive). `None` indicates no limit. ephemeris : str,\",\n \"Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey\",\n \"warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\")\",\n \"None: mask = (self.max >= illumination) | moon_down_mask elif self.max is None and\",\n \"rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1):\",\n \"in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is None: raise ValueError(\\\"Cannot have\",\n \"and worst (35) going to 0. For values outside the range, the rescale\",\n \"0. , 0. ]) \\\"\\\"\\\" rescaled = (vals - max_val) / (min_val -\",\n \"``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints]\",\n \"mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below ``horizon``. \\\"\\\"\\\"\",\n \"which targets are observable for an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division,\",\n \"is not None and self.max is not None: mask = ((self.min <= illumination)\",\n \"else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude =\",\n \"the observability information for each of the ``targets``. The table contains four columns\",\n \"None: mask = (self.min <= secz) & (secz <= self.max) else: raise ValueError(\\\"No\",\n \"is None: raise ValueError(\\\"You must at least supply either a minimum or a\",\n \"degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as\",\n \"def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be\",\n \"huge speedup if the end user # disables gridding and re-shapes the coords\",\n \"max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65\",\n \".. note:: This can misbehave if you try to constrain negative altitudes, as\",\n \"(solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\")\",\n \"as a SkyCoord object. Accessing the longitude # attribute of the frame data\",\n \"[0, 1). Default is one. Examples -------- To constrain observations on orbital phases\",\n \"min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates\",\n \"the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\"\",\n \"0 and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to\",\n \"return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun and some\",\n \"observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets`` are\",\n \"mask = (self.min <= illumination) & moon_up_mask elif self.min is not None and\",\n \"the coords themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure\",\n \"AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper\",\n \"= np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of time\",\n \"min altitude and 1 is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True):\",\n \"are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular\",\n \"def compute_constraint(self, times, observer, targets): # removed the location argument here, which causes\",\n \"\\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ----------\",\n \"spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution\",\n \"to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of\",\n \"targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output has\",\n \"None and self.max is not None: mask = ((self.min <= separation) & (separation\",\n \"for ``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters ----------\",\n \"Abstract class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self,\",\n \"than ``max_val`` should also return one, in some cases it should return zero)\",\n \"compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max\",\n \"and targets against each other if targets is not None: # broadcasting times\",\n \"rather than get sun here, since # it returns the Sun's coordinates in\",\n \"= datetime.time(23, 59, 59) # If time limits occur on same day: if\",\n \"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:,\",\n \"# the former calculates the separation in the frame of the moon coord\",\n \"timekey = (times.jd,) # make hashable thing from targets coords try: if hasattr(targets,\",\n \"for whether or not each target is observable in the time range given\",\n \"for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer,\",\n \"observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will also be\",\n \"of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or\",\n \"rely on broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result\",\n \"in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`\",\n \"target. `None` indicates no limit. min : float or `None` Minimum airmass of\",\n \"0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally:\",\n \"`~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``. This\",\n \"times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val,\",\n \"3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([\",\n \"max=0.6) The minimum and maximum phase must be described on the interval [0,\",\n \"``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters ---------- vals\",\n \"return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit for an\",\n \"observer, targets): timezone = None # get timezone from time objects, or from\",\n \"system. min : float (optional) Minimum phase (inclusive) on interval [0, 1). Default\",\n \"self.max else: max_time = datetime.time(23, 59, 59) # If time limits occur on\",\n \"information for each of the ``targets``. The table contains four columns with information\",\n \"max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase =\",\n \", 0. ]) \\\"\\\"\\\" rescaled = (vals - max_val) / (min_val - max_val)\",\n \"along the first index and times along the second. \\\"\\\"\\\" if times is\",\n \"(in some cases anything less than ``min_val`` should also return one, in some\",\n \"& (secz <= self.max) else: raise ValueError(\\\"No max and/or min specified in \\\"\",\n \"None and self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation\",\n \"of same length as ``targets`` for whether or not each target is ever\",\n \"= (self.min <= illumination) & moon_up_mask elif self.min is not None and self.max\",\n \"observable at each time in ``times``, given constraints in ``constraints`` for a particular\",\n \"unique and is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel())\",\n \"of 0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional\",\n \"`None` Minimum altitude of the target (inclusive). `None` indicates no limit. max :\",\n \"boolean_constraint : bool If True, the constraint is treated as a boolean (True\",\n \"self.min = min if max is None: self.max = 90*u.deg else: self.max =\",\n \"# find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude =\",\n \"@classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of\",\n \"ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\"\",\n \"times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH\",\n \"and self.max is None: raise ValueError(\\\"You must at least supply either a minimum\",\n \"and a maximum of 0.25 Parameters ---------- min : float or `None` (optional)\",\n \"class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary eclipse. \\\"\\\"\\\" def __init__(self,\",\n \"0.65 and no maximum Parameters ---------- min : float or `None` (optional) Minimum\",\n \"NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target. .. note:: This\",\n \"of a minimum of 0.25 and a maximum of 0.65 Parameters ---------- min\",\n \"``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution :\",\n \"if self.min is None and self.max is not None: mask = secz <=\",\n \"(60) going to 1 and worst (35) going to 0. For values outside\",\n \"the first index and times along the second. \\\"\\\"\\\" if times is None\",\n \"observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey = _make_cache_key(times,\",\n \"def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between civil twilights (-6 degrees).\",\n \"if self.boolean_constraint: if self.min is None and self.max is not None: mask =\",\n \"separation) & (separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in\",\n \": `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the\",\n \"_make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] =\",\n \"deg # innacuracies, but it is needed until astropy PR #5897 is released\",\n \"(inclusive) on interval [0, 1). Default is zero. max : float (optional) Maximum\",\n \"max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def\",\n \": float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no\",\n \"axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs,\",\n \"to 0) max_val : float best value cared about (rescales to 1) less_than_min\",\n \"return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the\",\n \": `~astropy.time.Time` Array of times on which to test the constraint. targets :\",\n \"is zero. max : float (optional) Maximum phase (inclusive) on interval [0, 1).\",\n \"targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or\",\n \"float AirmassConstraint if max is None.\\\") else: mx = self.max mi = 1\",\n \"moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and self.max is\",\n \"if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must\",\n \"which to compute the phase. For example, the system could be an eclipsing\",\n \"hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints = [constraint(observer,\",\n \"+ '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to reference\",\n \"\\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for solar\",\n \"is None and self.max is not None: mask = (self.max >= illumination) |\",\n \"are relatively slow # but there is potential for huge speedup if the\",\n \"\\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed\",\n \"**kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical twilights\",\n \"= tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer\",\n \"targets is slow due to # complex nature of these objects. We make\",\n \"which to test the constraint. observer : `~astroplan.Observer` The observer who has constraints\",\n \"# note to future editors - the order matters here # moon.separation(targets) is\",\n \"0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals - min_val) / (max_val\",\n \"test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets.\",\n \"targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable during ``time_range``\",\n \"abstractmethod import datetime import time import warnings # Third-party from astropy.time import Time\",\n \"= Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min =\",\n \"etc. \\\"\\\"\\\" # TODO: This method could be sped up a lot by\",\n \"\\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\",\",\n \"None and self.min is not None: mask = self.min <= solar_separation elif self.min\",\n \"of altitudes to be between 0 and 1, with the best (60) going\",\n \"sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the\",\n \"axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is\",\n \"and the ``max_val`` goes to zero. Parameters ---------- vals : array-like the values\",\n \"tuple for use as a cache key \\\"\\\"\\\" # make a tuple from\",\n \": 0 or 1 what is returned for ``vals`` below ``min_val``. (in some\",\n \"self.max is not None: mask = self.max >= solar_separation elif self.max is None\",\n \"lowermask = self.min <= alt uppermask = alt <= self.max return lowermask &\",\n \"(inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls,\",\n \"Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max if\",\n \"on time sequence If ``time_range`` is not specified, defaults to current year (localtime)\",\n \"times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable during ``time_range`` given\",\n \"altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude\",\n \"limit. boolean_constraint : bool If True, the constraint is treated as a boolean\",\n \"= dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining\",\n \"limit. ephemeris : str, optional Ephemeris to use. If not given, use the\",\n \"# needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def\",\n \"\\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly spaced between the two times\",\n \"observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times,\",\n \"return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary eclipse. \\\"\\\"\\\"\",\n \"= moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and self.max\",\n \"times along the second. \\\"\\\"\\\" if times is None and time_range is not\",\n \"is also satisfied if the Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None,\",\n \"This routine will provide an appropriate, hashable, key to store these calculations in\",\n \"to be between 0 and 1, with the best (60) going to 1\",\n \"targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min\",\n \"quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: #\",\n \"for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None,\",\n \"# If time limits occur on same day: if min_time < max_time: try:\",\n \"min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min =\",\n \"be for a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity`\",\n \"u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table\",\n \"**kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and\",\n \"(illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or min specified in\",\n \"= PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and\",\n \">= self.min) & (phase <= self.max), (phase >= self.min) | (phase <= self.max))\",\n \"the corresponding alt/az coordinates at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache\",\n \"Constrain observations to times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters\",\n \"times and (3) contains the moon illumination for those times. \\\"\\\"\\\" if not\",\n \"is not None: mask = secz <= self.max elif self.max is None and\",\n \"self.max = max def compute_constraint(self, times, observer, targets): # use get_body rather than\",\n \"mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's moon and some\",\n \"altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure\",\n \"times : `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the\",\n \">= separation elif self.max is None and self.min is not None: mask =\",\n \"= moon.separation(targets) if self.min is None and self.max is not None: mask =\",\n \"max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score (between\",\n \"``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val`` equal 1\",\n \"= as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2))\",\n \"Minimum altitude of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`\",\n \"of no minimum and a maximum of 0.25 Parameters ---------- min : float\",\n \"constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns -------\",\n \"time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range,\",\n \"times on which to test the constraint. observer : `~astroplan.Observer` The observer who\",\n \"If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or\",\n \"a SkyCoord object. Accessing the longitude # attribute of the frame data should\",\n \"certain time limits. An example use case for this class would be to\",\n \"time_grid_resolution) # TODO: This method could be sped up a lot by dropping\",\n \"mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the Earth's moon. Constraint\",\n \"and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between\",\n \"min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and\",\n \"(2.25). All values outside the range should return 0. >>> from astroplan.constraints import\",\n \"is None: timezone = observer.timezone if self.min is not None: min_time = self.min\",\n \"always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames,\",\n \"some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min :\",\n \"target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True)\",\n \"is not None: mask = self.min <= moon_separation elif self.min is not None\",\n \"self.min = min self.max = max def compute_constraint(self, times, observer, targets): # use\",\n \"self.min is None and self.max is not None: mask = self.max >= moon_separation\",\n \"Accessing the longitude # attribute of the frame data should be unique and\",\n \"want. moon_separation = moon.separation(targets) if self.min is None and self.max is not None:\",\n \"= (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate\",\n \"times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations\",\n \"times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to\",\n \"time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class Parameters ---------- observer\",\n \"and upper bounds on time sequence, with spacing ``time_resolution``. This will be passed\",\n \"= self.min <= moon_separation elif self.min is not None and self.max is not\",\n \"the time limits used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self,\",\n \"= self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase <=\",\n \"altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if\",\n \"shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result\",\n \"given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints =\",\n \"objects.\\\") if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits\",\n \"``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of\",\n \"``times`` in a cache on an ``observer``` object. This routine will provide an\",\n \"what is returned for ``vals`` above ``max_val``. (in some cases anything higher than\",\n \"self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between\",\n \"the upper limit on the airmass (``max``) and not the lower limit. Parameters\",\n \"no limit. \\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self, times, observer,\",\n \"aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0\",\n \"Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional\",\n \"max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"\\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls,\",\n \"use get_body rather than get sun here, since # it returns the Sun's\",\n \"Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint observer :\",\n \"a minimum of 0.65 and no maximum Parameters ---------- min : float or\",\n \"2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0.\",\n \"+ targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at\",\n \"constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time`\",\n \"fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to\",\n \"with grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object.\",\n \"target is ever observable at each time, given the constraints. \\\"\\\"\\\" if not\",\n \"0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled = (vals - max_val) / (min_val\",\n \"``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``.\",\n \"<= self.max elif self.max is None and self.min is not None: mask =\",\n \"time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for\",\n \"observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def\",\n \"float or `None` Maximum airmass of the target. `None` indicates no limit. min\",\n \"of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied\",\n \"work of computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time`\",\n \"to support the common case for users who care about the upper limit\",\n \"return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between\",\n \"= eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class\",\n \"SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on time\",\n \"Often, we wish to store expensive calculations for a combination of ``targets`` and\",\n \"(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable\",\n \"<= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or\",\n \"\\\"\\\"\\\" # make a tuple from times try: timekey = tuple(times.jd) + times.shape\",\n \"note to future editors - the order matters here # moon.separation(targets) is NOT\",\n \"------- array of floats between 0 and 1 inclusive rescaled so that ``vals``\",\n \"a combination of ``targets`` and ``times`` in a cache on an ``observer``` object.\",\n \"constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing\",\n \"override this. Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint\",\n \"into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints\",\n \"the table will be for a 24 hour period centered on that time.\",\n \"times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is\",\n \"if (min < 0) or (min > 1) or (max < 0) or\",\n \"coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the\",\n \"the ``max_val`` goes to zero. Parameters ---------- vals : array-like the values that\",\n \"min if max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint\",\n \"# make a tuple from times try: timekey = tuple(times.jd) + times.shape except\",\n \"self.max is not None: mask = ((self.min <= illumination) & (illumination <= self.max))\",\n \"moon_down_mask elif self.max is None and self.min is not None: mask = (self.min\",\n \"vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals,\",\n \"metadata entries ``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer`\",\n \"None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr =\",\n \"is None and self.min is not None: mask = self.min <= moon_separation elif\",\n \".utils import time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\",\",\n \"bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three\",\n \"\\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time =\",\n \"an ``observer``` object. This routine will provide an appropriate, hashable, key to store\",\n \"compute_constraint(self, times, observer, targets): # removed the location argument here, which causes small\",\n \"and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional)\",\n \"(optional) Minimum phase (inclusive) on interval [0, 1). Default is zero. max :\",\n \"a unique key to reference this combination of ``times`` and ``targets``. Often, we\",\n \"pairs. (1) 'times' contains the times for the alt/az computations, (2) 'altaz' contains\",\n \"and False for outside). If False, the constraint returns a float on [0,\",\n \"a float AirmassConstraint if max is None.\\\") else: mx = self.max mi =\",\n \"optional Ephemeris to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set``\",\n \"problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle\",\n \"observing time to be within certain time limits. An example use case for\",\n \"argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether\",\n \"same length as ``times`` for whether or not the target is ever observable\",\n \"between 0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal\",\n \"style license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which targets\",\n \"The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times\",\n \"self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer,\",\n \"columns with information about the target and it's observability: ``'target name'``, ``'ever observable'``,\",\n \"min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if\",\n \"The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or\",\n \"observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min)\",\n \"``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List of booleans\",\n \"to ``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples --------\",\n \"targets that are observable between 23:50 and 04:08 local time: >>> from astroplan\",\n \"first index and times along the second. \\\"\\\"\\\" if times is None and\",\n \"is not None: mask = (self.min <= illumination) & moon_up_mask elif self.min is\",\n \"max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0) or (min > 1)\",\n \"representing each month that a target is observable, one set per target. These\",\n \"relatively slow # but there is potential for huge speedup if the end\",\n \"(optional) If ``time_range`` is specified, determine whether constraints are met between test times\",\n \"constraint result with targets along the first index and times along the second.\",\n \": float (optional) Minimum phase (inclusive) on interval [0, 1). Default is zero.\",\n \"= targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer,\",\n \"35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy\",\n \"targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict\",\n \"(self.min <= secz) & (secz <= self.max) else: raise ValueError(\\\"No max and/or min\",\n \"[str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a\",\n \"tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times\",\n \"observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at these times\",\n \"self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime\",\n \"observations to targets that are observable between 23:50 and 04:08 local time: >>>\",\n \"worst (2.25). All values outside the range should return 0. >>> from astroplan.constraints\",\n \"two key-value pairs. (1) 'times' contains the times for the alt/az computations, (2)\",\n \"these objects. We make # to simple numpy arrays of the same shape\",\n \"_get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and\",\n \"min if min is not None else 0.0 self.max = max if max\",\n \"\\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc\",\n \"by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times,\",\n \"convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not\",\n \"are 1-based so that January maps to 1, February maps to 2, etc.\",\n \"of targets. Returns ------- cache_key : tuple A hashable tuple for use as\",\n \"linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table :\",\n \"a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25 Parameters\",\n \"= max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as\",\n \"met between test times in ``time_range`` by checking constraint at linearly-spaced times separated\",\n \"sure the output has the same shape as would result from # broadcasting\",\n \"= Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max\",\n \"= np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain\",\n \"return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination\",\n \"max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary eclipse.\",\n \"than ``min_val`` should also return one, in some cases it should return zero)\",\n \"= times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val,\",\n \"= solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between\",\n \"SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system):\",\n \"constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times\",\n \"= observer.pressure observer.pressure = 0 # find solar altitude at these times altaz\",\n \"min_val) below = vals < min_val above = vals > max_val rescaled[below] =\",\n \"target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum\",\n \"is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times)\",\n \"<= moon_separation elif self.min is not None and self.max is not None: mask\",\n \"self.min is not None: mask = (self.min <= illumination) & moon_up_mask elif self.min\",\n \"# convert times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey\",\n \"secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask =\",\n \"except BaseException: # must be scalar timekey = (times.jd,) # make hashable thing\",\n \"= min self.max = max def compute_constraint(self, times, observer, targets): # use get_body\",\n \"times try: timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar\",\n \"# but there is potential for huge speedup if the end user #\",\n \"= times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints]\",\n \"= _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey]\",\n \"arguments appear in the order (max, min) in this initializer to support the\",\n \"shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times,\",\n \"by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List of\",\n \": float or `None` Minimum airmass of the target. `None` indicates no limit.\",\n \"some cases it should return zero) Returns ------- array of floats between 0\",\n \"max_time for t in times.datetime]) except BaseException: # use np.bool so shape queries\",\n \"1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and those\",\n \"(self.min <= illumination) & moon_up_mask elif self.min is not None and self.max is\",\n \"must be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not None: if\",\n \"time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed for backward\",\n \"or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase (inclusive)\",\n \"this combination of ``times`` and ``targets``. Often, we wish to store expensive calculations\",\n \"{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict\",\n \"the Earth's moon. Constraint is also satisfied if the Moon has set. \\\"\\\"\\\"\",\n \"not None: mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask\",\n \"time limits. An example use case for this class would be to associate\",\n \"(vals - max_val) / (min_val - max_val) below = vals < min_val above\",\n \"not each target is observable in the time range given the constraints. \\\"\\\"\\\"\",\n \"or bool The constraints, with targets along the first index and times along\",\n \"along the second. \\\"\\\"\\\" if times is None and time_range is not None:\",\n \": str, optional Ephemeris to use. If not given, use the one set\",\n \"months_observable = [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for\",\n \"aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets)\",\n \"defaults of no minimum and a maximum of 0.25 Parameters ---------- min :\",\n \"self.max is not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be\",\n \"and times along the second. Otherwise, we rely on broadcasting the shapes together\",\n \"cared about (rescales to 1) greater_than_max : 0 or 1 what is returned\",\n \"unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime import time\",\n \"anything higher than ``max_val`` should also return one, in some cases it should\",\n \"at times linearly spaced between the two times in ``time_range`` with grid spacing\",\n \"eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times)\",\n \"az and illumination for an array of times for ``observer``. Cache the result\",\n \"an array of times for ``observer``. Cache the result on the ``observer`` object.\",\n \"astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided # Package\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time\",\n \"key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache\",\n \"civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\"\",\n \"goes to one, and the ``min_val`` goes to zero. Parameters ---------- vals :\",\n \"for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero\",\n \"from times try: timekey = tuple(times.jd) + times.shape except BaseException: # must be\",\n \"or (min > 1) or (max < 0) or (max > 1): raise\",\n \"subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\"\",\n \"equal 1 Examples -------- rescale an array of altitudes to be between 0\",\n \"bool Examples -------- To create a constraint that requires the airmass be \\\"better\",\n \"self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\"\",\n \"observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] =\",\n \"``min_val``. (in some cases anything less than ``min_val`` should also return one, in\",\n \"some cases anything higher than ``max_val`` should also return one, in some cases\",\n \"calculations for a combination of ``targets`` and ``times`` in a cache on an\",\n \"rescaled = (vals - max_val) / (min_val - max_val) below = vals <\",\n \"= times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1))\",\n \"and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times and (3)\",\n \"on interval [0, 1). Default is one. Examples -------- To constrain observations on\",\n \"output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times,\",\n \"times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times,\",\n \"entries ``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object),\",\n \"a cache on an ``observer``` object. This routine will provide an appropriate, hashable,\",\n \"[constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up\",\n \"the specified ``targets`` are observable for a specific ``observer``, given the supplied ``constraints``.\",\n \"Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \\\"\\\"\\\"\",\n \"see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which targets are observable for\",\n \"def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else:\",\n \"from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20,\",\n \"secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not\",\n \"-------- rescale airmasses to between 0 and 1, with the best (1) and\",\n \"max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with\",\n \": 0 or 1 what is returned for ``vals`` above ``max_val``. (in some\",\n \"> min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to\",\n \"targets along the first index and times along the second. \\\"\\\"\\\" # Should\",\n \"be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>>\",\n \"which to apply the constraints. Returns ------- constraint_result : 2D array of float\",\n \"Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains\",\n \"during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem`\",\n \"equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and\",\n \"find the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a\",\n \"an observer # centred frame, so the separation is as-seen # by the\",\n \"tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals,\",\n \"length as ``times`` for whether or not the target is ever observable at\",\n \"test the constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets\",\n \"targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\"\",\n \"return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's moon and\",\n \"shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0]\",\n \"separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A\",\n \"observability information for each of the ``targets``. The table contains four columns with\",\n \"1. , 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled = (vals -\",\n \"the target (inclusive). `None` indicates no limit. boolean_constraint : bool If True, the\",\n \"periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\"\",\n \"and maximum phase must be described on the interval [0, 1). To constrain\",\n \"targets): \\\"\\\"\\\" Make a unique key to reference this combination of ``times`` and\",\n \"min is not None else 0.0 self.max = max if max is not\",\n \"set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None,\",\n \"b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape\",\n \"separation between Sun and target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min =\",\n \"raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint):\",\n \"times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:,\",\n \"colnames = ['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names\",\n \"separation in the frame of the moon coord # which is GCRS, and\",\n \"0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals - min_val) / (max_val - min_val)\",\n \": 2D array of float or bool The constraints, with targets along the\",\n \"aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure\",\n \"find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt\",\n \"observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally:\",\n \"targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return\",\n \"be passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time,\",\n \"self.min <= secz elif self.min is not None and self.max is not None:\",\n \"speedup if the end user # disables gridding and re-shapes the coords themselves\",\n \"result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the real work\",\n \"plane and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"`~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer who has\",\n \"the range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy\",\n \"'fraction of time observable'] target_names = [target.name for target in targets] ever_obs =\",\n \"import warnings # Third-party from astropy.time import Time import astropy.units as u from\",\n \"the Earth's moon and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\"\",\n \"within' ' the interval [0, 1).') self.min = min if min is not\",\n \"import datetime import time import warnings # Third-party from astropy.time import Time import\",\n \"'times' contains the times for the alt/az computations, (2) 'altaz' contains the corresponding\",\n \"this class would be to associate an acceptable time range with a specific\",\n \"is not None: mask = (self.max >= illumination) | moon_down_mask elif self.max is\",\n \"time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] =\",\n \"degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as\",\n \"passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``\",\n \"times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make\",\n \"not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``\",\n \"min_val) / (max_val - min_val) below = vals < min_val above = vals\",\n \"``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints :\",\n \": `~astropy.time.Time` Array of times on which to test the constraint. observer :\",\n \"ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\"\",\n \"is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable\",\n \"from time objects, or from observer if self.min is not None: timezone =\",\n \"Constraint is also satisfied if the Moon has set. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"moon_separation elif self.max is None and self.min is not None: mask = self.min\",\n \"or list of targets. Returns ------- cache_key : tuple A hashable tuple for\",\n \"the Sun's coordinates in an observer # centred frame, so the separation is\",\n \"= self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max is\",\n \"!= np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer,\",\n \"& moon_up_mask elif self.min is not None and self.max is not None: mask\",\n \"``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times :\",\n \"**kwargs): \\\"\\\"\\\" Consider nighttime as time between civil twilights (-6 degrees). \\\"\\\"\\\" return\",\n \"one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min\",\n \"# Standard library from abc import ABCMeta, abstractmethod import datetime import time import\",\n \"observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`,\",\n \"as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes,\",\n \"{} # convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg\",\n \"observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey]\",\n \"' the interval [0, 1).') self.min = min if min is not None\",\n \"max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time\",\n \"no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon\",\n \"compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year)\",\n \"times in some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing\",\n \"min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz\",\n \"be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not None: if not\",\n \"specified as datetime.time objects.\\\") if self.max is not None: if not isinstance(self.max, datetime.time):\",\n \"between the Galactic plane and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\"\",\n \"timezone from time objects, or from observer if self.min is not None: timezone\",\n \"Examples -------- Constrain the observations to targets that are observable between 23:50 and\",\n \"illumination for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} #\",\n \"<= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return\",\n \"constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to compute\",\n \"has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional)\",\n \"(the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints,\",\n \"---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system\",\n \"target (inclusive). `None` indicates no limit. boolean_constraint : bool If True, the constraint\",\n \"are valid over the time limits used in calls to `is_observable` or `is_always_observable`.\",\n \"1 what is returned for ``vals`` below ``min_val``. (in some cases anything less\",\n \"Otherwise, we rely on broadcasting the shapes together using standard numpy rules. Returns\",\n \"twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider\",\n \"constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns\",\n \"---------- times : `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer`\",\n \"``max_val``. (in some cases anything higher than ``max_val`` should also return one, in\",\n \"``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational\",\n \"not None and self.max is not None: mask = ((self.min <= moon_separation) &\",\n \"return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to\",\n \"subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the\",\n \"`None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65,\",\n \"to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and 1,\",\n \"def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint =\",\n \"separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List\",\n \"the airmass be \\\"better than 2\\\", i.e. at a higher altitude than airmass=2::\",\n \"[constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return\",\n \"True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints]\",\n \"no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of\",\n \"= 0 # find solar altitude at these times altaz = observer.altaz(times, get_sun(times))\",\n \"given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints :\",\n \"1, with the best (1) and worst (2.25). All values outside the range\",\n \"to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on\",\n \"\\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\"\",\n \"the values that need to be rescaled to be between 0 and 1\",\n \"constraints. if targets.isscalar: # ensure we have a (1, 1) shape coord targets\",\n \"for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert\",\n \"targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask\",\n \"be \\\"better than 2\\\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\"\",\n \"bound times between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50),\",\n \"MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the Earth's moon. Constraint is also\",\n \"min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0) or (min >\",\n \"determine whether ``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list``\",\n \"about observability for all the ``targets`` over the requested ``time_range``, given the constraints\",\n \"maximum time.\\\") if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time\",\n \"be specified as datetime.time objects.\\\") if self.max is not None: if not isinstance(self.max,\",\n \"= min self.max = max if self.min is None and self.max is None:\",\n \"is NOT the same as targets.separation(moon) # the former calculates the separation in\",\n \"an array of times for ``targets`` and ``observer``. Cache the result on the\",\n \"slow due to # complex nature of these objects. We make # to\",\n \"bounds on time sequence, with spacing ``time_resolution``. This will be passed as the\",\n \"times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target\",\n \"self.min <= moon_separation elif self.min is not None and self.max is not None:\",\n \"if self.min is not None: timezone = self.min.tzinfo elif self.max is not None:\",\n \"= np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime]) except\",\n \"min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max\",\n \"datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone = None # get timezone\",\n \"some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\"\",\n \"if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure =\",\n \"linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable :\",\n \"observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if\",\n \"= 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if\",\n \"'_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing aakey =\",\n \"cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache =\",\n \"it returns the Sun's coordinates in an observer # centred frame, so the\",\n \"in the time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints\",\n \"be between 0 and 1 min_val : float worst acceptable value (rescales to\",\n \"1 Examples -------- rescale airmasses to between 0 and 1, with the best\",\n \"has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict\",\n \": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target (inclusive).\",\n \"requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints :\",\n \"\\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None:\",\n \"result from # broadcasting times and targets against each other if targets is\",\n \"24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def\",\n \"compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <=\",\n \">>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units\",\n \"mask = self.max >= separation elif self.max is None and self.min is not\",\n \"applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)\",\n \"not None: mask = (self.max >= illumination) | moon_down_mask elif self.max is None\",\n \"altitude of the target. .. note:: This can misbehave if you try to\",\n \"to 1) less_than_min : 0 or 1 what is returned for ``vals`` below\",\n \"0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses\",\n \"self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max))\",\n \"\\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit.\",\n \"self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function\",\n \"altitude of the target (inclusive). `None` indicates no limit. boolean_constraint : bool If\",\n \"if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must\",\n \"time.\\\") if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits\",\n \"returned for ``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should\",\n \"If True, the constraint is treated as a boolean (True for within the\",\n \"not None: mask = (self.min <= illumination) & moon_up_mask elif self.min is not\",\n \"and 1, with the best (60) going to 1 and worst (35) going\",\n \"# TODO: these broadcasting operations are relatively slow # but there is potential\",\n \"the corresponding alt/az coordinates at those times and (3) contains the moon illumination\",\n \">>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and 04:08\",\n \"warnings # Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates\",\n \"prior to evaluating multiple constraints. if targets.isscalar: # ensure we have a (1,\",\n \"[constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing\",\n \"is None else self.max mask = np.logical_and(times > min_time, times < max_time) return\",\n \"inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and those equal\",\n \"Array of times on which to test the constraint. observer : `~astroplan.Observer` The\",\n \"[0, 1). Default is zero. max : float (optional) Maximum phase (inclusive) on\",\n \"(phase <= self.max), (phase >= self.min) | (phase <= self.max)) return mask def\",\n \"`~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target (inclusive). `None`\",\n \"defaults of a minimum of 0.25 and a maximum of 0.65 Parameters ----------\",\n \"must be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with\",\n \"time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets`` are always observable throughout\",\n \"_make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to reference this combination of ``times``\",\n \"constraints = [constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times,\",\n \"is one. Examples -------- To constrain observations on orbital phases between 0.4 and\",\n \"observable in the time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'):\",\n \"airmasses to between 0 and 1, with the best (1) and worst (2.25).\",\n \"be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If\",\n \"in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints\",\n \"= np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else:\",\n \"specified, determine whether constraints are met between test times in ``time_range`` by checking\",\n \"not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise\",\n \"limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not None:\",\n \"from astropy.time import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01\",\n \"np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab\",\n \"astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary,\",\n \"observable at each time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints\",\n \"time import warnings # Third-party from astropy.time import Time import astropy.units as u\",\n \"is set to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max = max\",\n \"are met between test times in ``time_range`` by checking constraint at linearly-spaced times\",\n \"raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times,\",\n \"``targets`` are observable for a specific ``observer``, given the supplied ``constraints``. Parameters ----------\",\n \"self.max is not None: mask = ((self.min <= separation) & (separation <= self.max))\",\n \"'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure\",\n \"= self.min <= separation elif self.min is not None and self.max is not\",\n \"that ``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val`` equal\",\n \"times.shape except BaseException: # must be scalar timekey = (times.jd,) # make hashable\",\n \"Galactic, SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks import\",\n \"self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target. In the current\",\n \"is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) #\",\n \"shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape =\",\n \"constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list\",\n \"constraints are met between test times in ``time_range`` by checking constraint at linearly-spaced\",\n \"max_val : float best value cared about (rescales to 1) greater_than_max : 0\",\n \"first index and times along the second. Otherwise, we rely on broadcasting the\",\n \"Returns ------- constraint_result : 2D array of float or bool The constraints, with\",\n \"mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint):\",\n \"is None and self.max is not None: mask = self.max >= solar_separation elif\",\n \"\\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must\",\n \"strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a,\",\n \"of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional)\",\n \"a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer\",\n \"`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array of\",\n \"backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01',\",\n \"is not None and self.max is not None: mask = ((self.min <= moon_separation)\",\n \"one, in some cases it should return zero) Returns ------- array of floats\",\n \"``targets`` and ``times`` in a cache on an ``observer``` object. This routine will\",\n \"max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates\",\n \"(times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be\",\n \"is None.\\\") else: mx = self.max mi = 1 if self.min is None\",\n \"if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints\",\n \"0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination\",\n \"to one, and the ``max_val`` goes to zero. Parameters ---------- vals : array-like\",\n \"_get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination for an array\",\n \"is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets:\",\n \"applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr\",\n \"b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def\",\n \"self.max = max if self.min is None and self.max is None: raise ValueError(\\\"You\",\n \"1) less_than_min : 0 or 1 what is returned for ``vals`` below ``min_val``.\",\n \"`~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None`\",\n \"assume targets is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,)\",\n \"observations to times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ----------\",\n \"mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine\",\n \"and 04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints import\",\n \"for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer,\",\n \"hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude # attribute\",\n \"\\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute\",\n \"`~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range`` is not\",\n \"real work of computing the constraint. Subclasses override this. Parameters ---------- times :\",\n \"order matters here # moon.separation(targets) is NOT the same as targets.separation(moon) # the\",\n \"the end user # disables gridding and re-shapes the coords themselves # prior\",\n \"will provide an appropriate, hashable, key to store these calculations in a dictionary.\",\n \"compute the constraint observer : `~astroplan.Observer` the observaton location from which to apply\",\n \"in an observer # centred frame, so the separation is as-seen # by\",\n \"use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs.\",\n \"< 0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint must\",\n \"in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr\",\n \"to compute the constraint observer : `~astroplan.Observer` the observaton location from which to\",\n \"an array of altitudes to be between 0 and 1, with the best\",\n \"min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which\",\n \"the times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at\",\n \"\\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range =\",\n \"min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates\",\n \"no limit. min : float or `None` Minimum airmass of the target. `None`\",\n \"as a scalar. It also contains metadata entries ``'times'`` (with an array of\",\n \"argument here, which causes small <1 deg # innacuracies, but it is needed\",\n \"self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`\",\n \": `~astroplan.Observer` the observation location from which to apply the constraints targets :\",\n \"tuple(times.jd) + times.shape except BaseException: # must be scalar timekey = (times.jd,) #\",\n \"is ever observable at each time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints,\",\n \"the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or\",\n \"<= secz) & (secz <= self.max) else: raise ValueError(\\\"No max and/or min specified\",\n \"\\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize\",\n \"mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance\",\n \"raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target. .. note::\",\n \"Returns ------- cache_key : tuple A hashable tuple for use as a cache\",\n \"for each of the ``targets``. The table contains four columns with information about\",\n \"np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations\",\n \"import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from\",\n \"= [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\",\",\n \"same day: if min_time < max_time: try: mask = np.array([min_time <= t.time() <=\",\n \"None: mask = self.max >= solar_separation elif self.max is None and self.min is\",\n \"and self.max is not None: mask = ((self.min <= separation) & (separation <=\",\n \"BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return mask class\",\n \"`None` indicates no limit. boolean_constraint : bool If True, the constraint is treated\",\n \"observable', 'fraction of time observable'] target_names = [target.name for target in targets] ever_obs\",\n \"that requires the airmass be \\\"better than 2\\\", i.e. at a higher altitude\",\n \"/ (min_val - max_val) below = vals < min_val above = vals >\",\n \"solar_separation elif self.min is not None and self.max is not None: mask =\",\n \"constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour):\",\n \"def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets``\",\n \"altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr\",\n \"greater_than_max : 0 or 1 what is returned for ``vals`` above ``max_val``. (in\",\n \"max def compute_constraint(self, times, observer, targets): # use get_body rather than get sun\",\n \"times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in\",\n \"a lot by dropping to the trigonometric # altitude calculations. if not hasattr(constraints,\",\n \"= observer.timezone if self.min is not None: min_time = self.min else: min_time =\",\n \"trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times =\",\n \"array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the\",\n \"as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone = None # get\",\n \"given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by\",\n \"the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for\",\n \"(inclusive). `None` indicates no limit. max : float or `None` (optional) Maximum acceptable\",\n \"times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable at each time in\",\n \"that ``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val`` equal\",\n \"\\\"\\\"\\\" rescaled = (vals - max_val) / (min_val - max_val) below = vals\",\n \"- min_val) below = vals < min_val above = vals > max_val rescaled[below]\",\n \"numpy arrays of the same shape and # broadcast these to find the\",\n \"else 0.0 self.max = max if max is not None else 1.0 def\",\n \"limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples --------\",\n \"= dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times,\",\n \"mask = np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase\",\n \"= None # get timezone from time objects, or from observer if self.min\",\n \"None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified as \\\"\",\n \"PR #5897 is released # which should be astropy 1.3.2 moon = get_moon(times,\",\n \"if min is not None else 0.0 self.max = max if max is\",\n \"is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints]\",\n \"observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey]\",\n \"1 min_val : float worst acceptable value (rescales to 0) max_val : float\",\n \"if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure =\",\n \"None else self.max mask = np.logical_and(times > min_time, times < max_time) return mask\",\n \"<= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified\",\n \"the system could be an eclipsing or non-eclipsing binary, or exoplanet system. min\",\n \"times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list\",\n \"get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters here #\",\n \"min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask =\",\n \"boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times,\",\n \"not None and self.max is not None: mask = ((self.min <= solar_separation) &\",\n \"time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour\",\n \"\\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year =\",\n \"Galactic latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or\",\n \"end user # disables gridding and re-shapes the coords themselves # prior to\",\n \"# If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time)\",\n \"import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30, 40,\",\n \"second. Otherwise, we rely on broadcasting the shapes together using standard numpy rules.\",\n \"mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No max\",\n \"zero and one), where the ``min_val`` goes to one, and the ``max_val`` goes\",\n \"of the same shape and # broadcast these to find the correct shape\",\n \"def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the real work of computing\",\n \"_get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt\",\n \"equal 0 and those equal to ``max_val`` equal 1 Examples -------- rescale an\",\n \"(optional) Lower and upper bounds on time sequence If ``time_range`` is not specified,\",\n \"'__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for\",\n \"spacing grid_times_targets : bool if True, grids the constraint result with targets along\",\n \"``max_val`` goes to zero. Parameters ---------- vals : array-like the values that need\",\n \"have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets\",\n \"the airmass of a target. In the current implementation the airmass is approximated\",\n \"BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which\",\n \">= solar_separation elif self.max is None and self.min is not None: mask =\",\n \"array of float or bool The constraints, with targets along the first index\",\n \"limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and\",\n \"Constrain observations to times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters\",\n \": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional)\",\n \"case for this class would be to associate an acceptable time range with\",\n \"separation between Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`\",\n \"doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\"\",\n \"combination of ``targets`` and ``times`` in a cache on an ``observer``` object. This\",\n \"is not None and self.max is not None: mask = ((self.min <= separation)\",\n \"targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If\",\n \"__future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta,\",\n \"astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy\",\n \"= min if min is not None else 0.0 self.max = max if\",\n \"to 1, February maps to 2, etc. \\\"\\\"\\\" # TODO: This method could\",\n \"'always observable', 'fraction of time observable'] target_names = [target.name for target in targets]\",\n \"limits must be specified as datetime.time objects.\\\") if self.max is not None: if\",\n \"return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache\",\n \"in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is\",\n \"range given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints\",\n \"`~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum of 0.65\",\n \"the same as targets.separation(moon) # the former calculates the separation in the frame\",\n \"the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range :\",\n \"force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between civil twilights\",\n \"<= solar_separation elif self.min is not None and self.max is not None: mask\",\n \"return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational constraints.\",\n \"and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min =\",\n \"times linearly spaced between the two times in ``time_range`` with grid spacing ``time_resolution``\",\n \"second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if\",\n \"needed until astropy PR #5897 is released # which should be astropy 1.3.2\",\n \"is not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else:\",\n \">>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime\",\n \"minimum of 0.25 and a maximum of 0.65 Parameters ---------- min : float\",\n \"`~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets\",\n \"constraint_result : 1D or 2D array of float or bool The constraints. If\",\n \"altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if\",\n \"the separation in the frame of the moon coord # which is GCRS,\",\n \"with the best (1) and worst (2.25). All values outside the range should\",\n \"who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of\",\n \"None: mask = ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\\\"No\",\n \"[] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in\",\n \"not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise\",\n \"or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris\",\n \"of targets times : `~astropy.time.Time` (optional) Array of times on which to test\",\n \"released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note\",\n \"self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else\",\n \"0 and those equal to ``max_val`` equal 1 Examples -------- rescale an array\",\n \"<= secz elif self.min is not None and self.max is not None: mask\",\n \"negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min\",\n \"for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should also\",\n \"containing two key-value pairs. (1) 'times' contains the times for the alt/az computations,\",\n \"transit for an array of times for ``targets`` and ``observer``. Cache the result\",\n \"max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"min_val above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max return\",\n \"self.min <= solar_separation elif self.min is not None and self.max is not None:\",\n \"np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets):\",\n \"datetime.time(0, 0, 0) if self.max is not None: max_time = self.max else: max_time\",\n \"self.min is None else self.min # values below 1 should be disregarded return\",\n \"observing block. This can be useful if not all observing blocks are valid\",\n \"The ``max`` and ``min`` arguments appear in the order (max, min) in this\",\n \"None: min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0) if\",\n \"useful if not all observing blocks are valid over the time limits used\",\n \"To create a constraint that requires the airmass be \\\"better than 2\\\", i.e.\",\n \"float (optional) Minimum phase (inclusive) on interval [0, 1). Default is zero. max\",\n \"are observable for an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals)\",\n \"observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return\",\n \"anything less than ``min_val`` should also return one, in some cases it should\",\n \"meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times\",\n \"targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times\",\n \"target. .. note:: This can misbehave if you try to constrain negative altitudes,\",\n \"zenith angle. .. note:: The ``max`` and ``min`` arguments appear in the order\",\n \"observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit for\",\n \"else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target,\",\n \"Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive).\",\n \"frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs])\",\n \"times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey]\",\n \"Array of times on which to test the constraint time_range : `~astropy.time.Time` (optional)\",\n \"for a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional)\",\n \"self.max is None else self.max mask = np.logical_and(times > min_time, times < max_time)\",\n \"Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is\",\n \"applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer,\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever\",\n \"---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it is\",\n \"min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum\",\n \"is not None: mask = self.min <= secz elif self.min is not None\",\n \"given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by\",\n \"time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import\",\n \"= observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\"\",\n \"Constrain the altitude of the target. .. note:: This can misbehave if you\",\n \": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None`\",\n \"and self.max is not None: mask = secz <= self.max elif self.max is\",\n \"of booleans of same length as ``times`` for whether or not the target\",\n \"None and self.max is not None: mask = ((self.min <= illumination) & (illumination\",\n \": `~numpy.ndarray` Array of booleans of same length as ``times`` for whether or\",\n \"not None: mask = self.min <= solar_separation elif self.min is not None and\",\n \"Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max : float or\",\n \"# innacuracies, but it is needed until astropy PR #5897 is released #\",\n \"the Sun that can occur when the Sun is below the horizon and\",\n \"`~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest\",\n \"to evaluating multiple constraints. if targets.isscalar: # ensure we have a (1, 1)\",\n \"system could be an eclipsing or non-eclipsing binary, or exoplanet system. min :\",\n \"a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min\",\n \"time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target\",\n \"store expensive calculations for a combination of ``targets`` and ``times`` in a cache\",\n \"`~astropy.time.Time` Array of times on which to test the constraint observer : `~astroplan.Observer`\",\n \"be scalar timekey = (times.jd,) # make hashable thing from targets coords try:\",\n \"``time_range`` is specified, determine whether constraints are met between test times in ``time_range``\",\n \"times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about observability for all\",\n \"for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets):\",\n \"Lower and upper bounds on time sequence If ``time_range`` is not specified, defaults\",\n \"cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`\",\n \"a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None):\",\n \"1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and those\",\n \"containing a key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer,\",\n \"``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'``\",\n \"time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times']\",\n \"hashable, key to store these calculations in a dictionary. Parameters ---------- times :\",\n \"or not each target is ever observable in the time range given the\",\n \"which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times,\",\n \"solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in\",\n \"max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is\",\n \"or `None` (optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates\",\n \"observer # centred frame, so the separation is as-seen # by the observer.\",\n \"& (phase <= self.max), (phase >= self.min) | (phase <= self.max)) return mask\",\n \"the ``target`` is observable at each time in ``times``, given constraints in ``constraints``\",\n \"requires the airmass be \\\"better than 2\\\", i.e. at a higher altitude than\",\n \"appropriate, hashable, key to store these calculations in a dictionary. Parameters ---------- times\",\n \"observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to\",\n \"astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5,\",\n \"Lower and upper bounds on time sequence, with spacing ``time_resolution``. This will be\",\n \"\\\"\\\"\\\" Constrain the distance between the Sun and some targets. \\\"\\\"\\\" def __init__(self,\",\n \"times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint:\",\n \"[constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints]\",\n \"and times along the second. \\\"\\\"\\\" # Should be implemented on each subclass\",\n \"observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >=\",\n \"self.min is not None and self.max is not None: mask = ((self.min <=\",\n \"hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar:\",\n \"Cache the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array\",\n \"constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always\",\n \"def compute_constraint(self, times, observer, targets): timezone = None # get timezone from time\",\n \"> max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val,\",\n \"as time between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def\",\n \"order (max, min) in this initializer to support the common case for users\",\n \": `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system\",\n \"is needed until astropy PR #5897 is released # which should be astropy\",\n \"\\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the Earth's\",\n \"correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x,\",\n \"Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets\",\n \"astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\")\",\n \"with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time\",\n \"**kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and\",\n \"0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint\",\n \"else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz\",\n \"a score (between zero and one), where the ``max_val`` goes to one, and\",\n \"index and times along the second. Otherwise, we rely on broadcasting the shapes\",\n \"compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if\",\n \"for outside). If False, the constraint returns a float on [0, 1], where\",\n \"values that need to be rescaled to be between 0 and 1 min_val\",\n \"the former calculates the separation in the frame of the moon coord #\",\n \"should return 0 below 35 and 1 above 60. >>> from astroplan.constraints import\",\n \"defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,\",\n \"datetime.time objects.\\\") if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time\",\n \"is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None:\",\n \"constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\"\",\n \"mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during\",\n \"pairs. (1) 'times' contains the times for the computations, (2) 'altaz' contains the\",\n \"0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1)\",\n \"<= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within\",\n \"for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable',\",\n \"np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target``\",\n \"phase (inclusive) on interval [0, 1). Default is zero. max : float (optional)\",\n \"be between 0 and 1, with the best (60) going to 1 and\",\n \"bool if True, grids the constraint result with targets along the first index\",\n \", 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals - min_val) /\",\n \"target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable at each time\",\n \"than 2\\\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self,\",\n \"`~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array of times\",\n \"1). Default is zero. max : float (optional) Maximum phase (inclusive) on interval\",\n \"= [constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True)\",\n \"WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2)\",\n \"in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz =\",\n \"None: timezone = observer.timezone if self.min is not None: min_time = self.min else:\",\n \"mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below ``horizon``.\",\n \"Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`\",\n \"the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table =\",\n \": list List of sets of unique integers representing each month that a\",\n \"self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\")\",\n \"and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time >>>\",\n \"between 0.6 and 1.2, for example, you should subtract one from the second\",\n \"targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure\",\n \"is None and self.min is not None: mask = self.min <= solar_separation elif\",\n \"on which to apply the constraints. times : `~astropy.time.Time` The times to compute\",\n \"and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets =\",\n \"airmass of the target. `None` indicates no limit. boolean_contstraint : bool Examples --------\",\n \"what we want. moon_separation = moon.separation(targets) if self.min is None and self.max is\",\n \"of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence\",\n \"to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for\",\n \"(optional) Array of mid-event times on which to test the constraints times_ingress_egress :\",\n \"at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True):\",\n \"`~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for a 24\",\n \"is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint\",\n \"limit. max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None`\",\n \"the zenith angle. .. note:: The ``max`` and ``min`` arguments appear in the\",\n \"illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure =\",\n \"[constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr,\",\n \"= boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt\",\n \"\\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple\",\n \"class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target. .. note:: This can\",\n \"This can misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz`\",\n \"with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of\",\n \"given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times\",\n \"as datetime.time objects.\\\") if self.max is not None: if not isinstance(self.max, datetime.time): raise\",\n \"eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint):\",\n \"to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache:\",\n \"cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask\",\n \"astropy.time import Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon,\",\n \"Constrain the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True):\",\n \"not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified as\",\n \"max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within certain\",\n \"of the zenith angle. .. note:: The ``max`` and ``min`` arguments appear in\",\n \"if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint\",\n \"<= self.max) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return\",\n \"``targets``. Often, we wish to store expensive calculations for a combination of ``targets``\",\n \"if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max return\",\n \"tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1):\",\n \"(optional) Maximum phase (inclusive) on interval [0, 1). Default is one. Examples --------\",\n \"each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of\",\n \"blocks are valid over the time limits used in calls to `is_observable` or\",\n \"hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True)\",\n \"or `None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint :\",\n \"class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary eclipse. \\\"\\\"\\\" def __init__(self,\",\n \"_make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure\",\n \"# complex nature of these objects. We make # to simple numpy arrays\",\n \"min_time = self.min = datetime.time(0, 0, 0) if self.max is not None: max_time\",\n \"0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled = (vals - max_val) /\",\n \"self.min is None and self.max is None: raise ValueError(\\\"You must at least supply\",\n \"try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination\",\n \"constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list,\",\n \"ever_observable : list List of booleans of same length as ``targets`` for whether\",\n \"class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target. In the current implementation\",\n \"import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\",\",\n \"rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an\",\n \"be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors -\",\n \"times for ``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters\",\n \"\\\"\\\"\\\" # TODO: This method could be sped up a lot by dropping\",\n \"self.max is not None: timezone = self.max.tzinfo if timezone is None: timezone =\",\n \"`None` indicates no limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates\",\n \"t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <=\",\n \"of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] =\",\n \"np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do\",\n \"calculations. This avoids errors in the altitude of the Sun that can occur\",\n \"# first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt\",\n \"max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or `None` (optional) Minimum acceptable\",\n \"targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"object. Accessing the longitude # attribute of the frame data should be unique\",\n \"observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask\",\n \"and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as\",\n \"expensive calculations for a combination of ``targets`` and ``times`` in a cache on\",\n \"altitude and 1 is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if\",\n \"if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar')\",\n \">>> import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound\",\n \"the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times on which\",\n \"self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask\",\n \"with targets along the first index and times along the second. \\\"\\\"\\\" #\",\n \"raise ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint):\",\n \"# disables gridding and re-shapes the coords themselves # prior to evaluating multiple\",\n \"above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max return rescaled\",\n \"class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\"\",\n \"given as a scalar. It also contains metadata entries ``'times'`` (with an array\",\n \"(-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not\",\n \"if the ``target`` is observable at each time in ``times``, given constraints in\",\n \"= abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask =\",\n \"0) max_val : float best value cared about (rescales to 1) greater_than_max :\",\n \"& uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass\",\n \"_make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure\",\n \"ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is\",\n \"min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates\",\n \">>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max\",\n \"= Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask = np.logical_and(times > min_time,\",\n \"list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints\",\n \"import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1\",\n \"This can be useful if not all observing blocks are valid over the\",\n \"None and self.max is not None: mask = (self.max >= illumination) | moon_down_mask\",\n \"in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range,\",\n \"a scalar. It also contains metadata entries ``'times'`` (with an array of all\",\n \"if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] =\",\n \"score (between zero and one), where the ``min_val`` goes to one, and the\",\n \"'builtin' by default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris\",\n \"potential for huge speedup if the end user # disables gridding and re-shapes\",\n \"= max if self.min is None and self.max is None: raise ValueError(\\\"You must\",\n \"can misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame\",\n \"determine whether constraints are met between test times in ``time_range`` by checking constraint\",\n \"``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list List of sets\",\n \"or not each target is observable in the time range given the constraints.\",\n \"# bound times between 23:50 and 04:08 local Hawaiian time >>> constraint =\",\n \"a cache key \\\"\\\"\\\" # make a tuple from times try: timekey =\",\n \"= boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz\",\n \"Minimum acceptable separation between Sun and target (inclusive). `None` indicates no limit. max\",\n \"Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord\",\n \"maximum of 0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable\",\n \"np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer,\",\n \"between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\"\",\n \"the ``targets``. The table contains four columns with information about the target and\",\n \"target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs =\",\n \"def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude\",\n \"should return zero) Returns ------- array of floats between 0 and 1 inclusive\",\n \"and upper bounds on time sequence If ``time_range`` is not specified, defaults to\",\n \"moon_separation = moon.separation(targets) if self.min is None and self.max is not None: mask\",\n \"None and self.min is not None: mask = (self.min <= illumination) & moon_up_mask\",\n \"<= self.max), (phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints,\",\n \"goes to one, and the ``max_val`` goes to zero. Parameters ---------- vals :\",\n \"0 and 1 min_val : float worst acceptable value (rescales to 0) max_val\",\n \"atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod\",\n \"return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>>\",\n \"\\\"\\\"\\\" Determines if the ``target`` is observable at each time in ``times``, given\",\n \"Sun that can occur when the Sun is below the horizon and the\",\n \"float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit.\",\n \"altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure\",\n \"If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to\",\n \"axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab =\",\n \"_get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly spaced\",\n \"(vals - min_val) / (max_val - min_val) below = vals < min_val above\",\n \"``'fraction of time observable'``. The column ``'time observable'`` will also be present if\",\n \"targets) # make sure the output has the same shape as would result\",\n \"55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0.\",\n \"None: mask = self.max >= separation elif self.max is None and self.min is\",\n \"unique integers representing each month that a target is observable, one set per\",\n \"def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination for an\",\n \"# values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class\",\n \"between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs):\",\n \"1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest:\",\n \"at those times and (3) contains the moon illumination for those times. \\\"\\\"\\\"\",\n \"---------- max : float or `None` Maximum airmass of the target. `None` indicates\",\n \"create a constraint that requires the airmass be \\\"better than 2\\\", i.e. at\",\n \"None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask\",\n \"\\\"\\\"\\\" Constrain observations to times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\"\",\n \"shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) #\",\n \"and re-shapes the coords themselves # prior to evaluating multiple constraints. if targets.isscalar:\",\n \"& moon_up_mask else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return\",\n \"times for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times\",\n \"second. \\\"\\\"\\\" if times is None and time_range is not None: times =\",\n \"v targets is slow due to # complex nature of these objects. We\",\n \"times.datetime]) except BaseException: # use np.bool so shape queries don't cause problems mask\",\n \"between test times in ``time_range`` by checking constraint at linearly-spaced times separated by\",\n \"<= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return\",\n \"1. ]) \\\"\\\"\\\" rescaled = (vals - min_val) / (max_val - min_val) below\",\n \"1D or 2D array of float or bool The constraints. If 2D with\",\n \"isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") def\",\n \"no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs):\",\n \"no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): #\",\n \"approximated by the secant of the zenith angle. .. note:: The ``max`` and\",\n \"of times on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower\",\n \"= Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31']\",\n \"set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min =\",\n \"min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None`\",\n \"`None` indicates no limit. max : float or `None` (optional) Maximum acceptable fractional\",\n \"mi = 1 if self.min is None else self.min # values below 1\",\n \"a 3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints to\",\n \"import ABCMeta, abstractmethod import datetime import time import warnings # Third-party from astropy.time\",\n \"limit. min : float or `None` Minimum airmass of the target. `None` indicates\",\n \"the times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates\",\n \"max_val) below = vals < min_val above = vals > max_val rescaled[below] =\",\n \"= [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr,\",\n \"of times on which to test the constraint. observer : `~astroplan.Observer` The observer\",\n \"+ targets.shape else: # assume targets is a string. targkey = (targets,) except\",\n \"we rely on broadcasting the shapes together using standard numpy rules. Returns -------\",\n \"`~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target (inclusive). `None`\",\n \"1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False)\",\n \"as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50\",\n \"\\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range\",\n \"force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon\",\n \"or `None` (optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates\",\n \"TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets):\",\n \"Target or list of targets. Returns ------- cache_key : tuple A hashable tuple\",\n \"so that ``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val``\",\n \"Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains\",\n \"maximum of 0.65 Parameters ---------- min : float or `None` (optional) Minimum acceptable\",\n \"None: raise ValueError(\\\"You must at least supply either a minimum or a \\\"\",\n \"array ``vals`` to be a score (between zero and one), where the ``max_val``\",\n \"constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key :\",\n \"Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask = np.logical_and(times > min_time, times\",\n \"constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None):\",\n \"initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum\",\n \"eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint):\",\n \"0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure:\",\n \"the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,\",\n \"targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames\",\n \"``max_val`` should also return one, in some cases it should return zero) Returns\",\n \"limit. Examples -------- Constrain the observations to targets that are observable between 2016-03-28\",\n \"a maximum of 0.25 Parameters ---------- min : float or `None` (optional) Minimum\",\n \"class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic plane and some targets.\",\n \"ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\"\",\n \"timezone = observer.timezone if self.min is not None: min_time = self.min else: min_time\",\n \"ingress and egress times for ``N`` events, with shape (``N``, 2). Returns -------\",\n \"to be between 0 and 1 min_val : float worst acceptable value (rescales\",\n \"observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude =\",\n \"but there is potential for huge speedup if the end user # disables\",\n \"aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0\",\n \"make # to simple numpy arrays of the same shape and # broadcast\",\n \"spaced between the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``.\",\n \"the airmass is approximated by the secant of the zenith angle. .. note::\",\n \"a maximum of 0.65 Parameters ---------- min : float or `None` (optional) Minimum\",\n \"mask = self.min <= separation elif self.min is not None and self.max is\",\n \"self.min = datetime.time(0, 0, 0) if self.max is not None: max_time = self.max\",\n \"as np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from\",\n \"on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress\",\n \"(min_val - max_val) below = vals < min_val above = vals > max_val\",\n \"------- ever_observable : list List of booleans of same length as ``targets`` for\",\n \"in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask\",\n \"returned for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should\",\n \"indicates no limit. \\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self, times,\",\n \"max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4,\",\n \"import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day)\",\n \"max : float (optional) Maximum phase (inclusive) on interval [0, 1). Default is\",\n \"below the horizon and the corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\"\",\n \"the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to\",\n \"= observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] =\",\n \"class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer,\",\n \"the Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ----------\",\n \"max_time: try: mask = np.array([min_time <= t.time() <= max_time for t in times.datetime])\",\n \"is observable, one set per target. These integers are 1-based so that January\",\n \"if self.max is None: raise ValueError(\\\"Cannot have a float AirmassConstraint if max is\",\n \"targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times)\",\n \"Make a unique key to reference this combination of ``times`` and ``targets``. Often,\",\n \"---------- min : float or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None`\",\n \"be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings():\",\n \"self.max mask = np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint):\",\n \"and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude #\",\n \"a minimum or a maximum time.\\\") if self.min is not None: if not\",\n \"<= separation) & (separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified\",\n \"convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey\",\n \"a target is observable, one set per target. These integers are 1-based so\",\n \"np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) #\",\n \"the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint\",\n \"(rescales to 1) greater_than_max : 0 or 1 what is returned for ``vals``\",\n \"zero for solar altitude calculations. This avoids errors in the altitude of the\",\n \"to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of\",\n \"``observer``. Cache the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time`\",\n \"not None: mask = ((self.min <= separation) & (separation <= self.max)) else: raise\",\n \"specific observing block. This can be useful if not all observing blocks are\",\n \"Earth's moon and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters\",\n \"targets times : `~astropy.time.Time` (optional) Array of times on which to test the\",\n \"# prior to evaluating multiple constraints. if targets.isscalar: # ensure we have a\",\n \"minimum of the PhaseConstraint must be within' ' the interval [0, 1).') self.min\",\n \"along the first index and times along the second. Otherwise, we rely on\",\n \"if not all observing blocks are valid over the time limits used in\",\n \"`~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper\",\n \"\\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's\",\n \"\\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which\",\n \">>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru =\",\n \"``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range :\",\n \">>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be\",\n \"* len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape\",\n \"is None: self.min = -90*u.deg else: self.min = min if max is None:\",\n \"altitude of the Sun that can occur when the Sun is below the\",\n \"hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat as a\",\n \"that need to be rescaled to be between 0 and 1 min_val :\",\n \"use as a cache key \\\"\\\"\\\" # make a tuple from times try:\",\n \"hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for hashing\",\n \"\\\"\\\"\\\" Constrain the altitude of the target. .. note:: This can misbehave if\",\n \"\\\"better than 2\\\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def\",\n \"by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours.\",\n \"be present if the ``time_range`` is given as a scalar. It also contains\",\n \"target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use.\",\n \"__init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum\",\n \"Earth's moon. Constraint is also satisfied if the Moon has set. \\\"\\\"\\\" def\",\n \"(inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max = max def\",\n \"the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will\",\n \"information about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``,\",\n \"times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in\",\n \"for t in times.datetime]) except BaseException: # use np.bool so shape queries don't\",\n \"and self.min is not None: mask = self.min <= moon_separation elif self.min is\",\n \"hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints =\",\n \"is None and self.max is not None: mask = self.max >= separation elif\",\n \"= np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure\",\n \"\\\"\\\"\\\" Constrain the fractional illumination of the Earth's moon. Constraint is also satisfied\",\n \"or (max < 0) or (max > 1): raise ValueError('The minimum of the\",\n \"for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list\",\n \"observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully\",\n \"constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and\",\n \"cache on an ``observer``` object. This routine will provide an appropriate, hashable, key\",\n \"compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"self.max >= solar_separation elif self.max is None and self.min is not None: mask\",\n \"non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase (inclusive) on\",\n \"= force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between civil\",\n \"Maximum acceptable separation between moon and target (inclusive). `None` indicates no limit. ephemeris\",\n \"The targets on which to apply the constraints. times : `~astropy.time.Time` The times\",\n \"cases anything higher than ``max_val`` should also return one, in some cases it\",\n \"limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\"\",\n \"key to reference this combination of ``times`` and ``targets``. Often, we wish to\",\n \"an appropriate, hashable, key to store these calculations in a dictionary. Parameters ----------\",\n \"get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as np\",\n \"a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey +\",\n \"the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min\",\n \"= [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target,\",\n \"Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max\",\n \"in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\"\",\n \"time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets`` are observable for a specific\",\n \"are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from\",\n \"for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times =\",\n \"# cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure =\",\n \"2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time >>> subaru\",\n \"< 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is\",\n \"binary, or exoplanet system. min : float (optional) Minimum phase (inclusive) on interval\",\n \"to be a score (between zero and one), where the ``max_val`` goes to\",\n \"unique key to reference this combination of ``times`` and ``targets``. Often, we wish\",\n \"hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure:\",\n \"is None and self.min is not None: mask = self.min <= secz elif\",\n \"Sun is below the horizon and the corrections for atmospheric refraction return nonsense\",\n \"for huge speedup if the end user # disables gridding and re-shapes the\",\n \"of 0.65 and no maximum Parameters ---------- min : float or `None` (optional)\",\n \"either a minimum or a \\\" \\\"maximum time.\\\") if self.min is not None:\",\n \"(in some cases anything higher than ``max_val`` should also return one, in some\",\n \"return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals``\",\n \"throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ----------\",\n \"the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a particular\",\n \"class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun and some targets. \\\"\\\"\\\"\",\n \"as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time\",\n \"one, and the ``max_val`` goes to zero. Parameters ---------- vals : array-like the\",\n \"target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max = max\",\n \"constraint that requires the airmass be \\\"better than 2\\\", i.e. at a higher\",\n \"\\\"\\\"\\\" Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination\",\n \"calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on\",\n \"times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for\",\n \"[target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1)\",\n \"altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets):\",\n \"is the min altitude and 1 is the max. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum of\",\n \"table contains four columns with information about the target and it's observability: ``'target\",\n \"targets): # use get_body rather than get sun here, since # it returns\",\n \"and constraints to determine which targets are observable for an observer. \\\"\\\"\\\" from\",\n \"(inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use. If\",\n \"self.max = max if max is not None else 1.0 def compute_constraint(self, times,\",\n \"0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array\",\n \"astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u\",\n \"it is considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the\",\n \"in a cache on an ``observer``` object. This routine will provide an appropriate,\",\n \"Sun and target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max\",\n \"to determine whether ``targets`` are always observable throughout ``time_range`` given constraints in the\",\n \"the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\"\",\n \"objects.\\\") def compute_constraint(self, times, observer, targets): timezone = None # get timezone from\",\n \"\\\"\\\"\\\" Determines which month the specified ``targets`` are observable for a specific ``observer``,\",\n \"= {} # convert times, targets to tuple for hashing aakey = _make_cache_key(times,\",\n \"to targets that are observable between 23:50 and 04:08 local time: >>> from\",\n \"return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain\",\n \": float or `None` Maximum airmass of the target. `None` indicates no limit.\",\n \"Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target. ..\",\n \"not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") if\",\n \"are observable for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints\",\n \"print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime import\",\n \"of `~astroplan.Target` The targets on which to apply the constraints. times : `~astropy.time.Time`\",\n \"same shape as would result from # broadcasting times and targets against each\",\n \"/ constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None\",\n \"calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr =\",\n \"times v targets is slow due to # complex nature of these objects.\",\n \"times, observer, targets): # first is the moon up? cached_moon = _get_moon_data(times, observer)\",\n \"constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction\",\n \"`~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND\",\n \"= np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if\",\n \": bool (optional) Force the pressure to zero for solar altitude calculations. This\",\n \"rescale airmasses to between 0 and 1, with the best (1) and worst\",\n \"best (60) going to 1 and worst (35) going to 0. For values\",\n \"times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is not\",\n \"\\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the\",\n \"= observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit\",\n \"24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range``\",\n \"1 if self.min is None else self.min # values below 1 should be\",\n \"latitude of target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`\",\n \"set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min =\",\n \"WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length\",\n \"is None: raise ValueError(\\\"Cannot have a float AirmassConstraint if max is None.\\\") else:\",\n \"dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational\",\n \"set to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris\",\n \"is as-seen # by the observer. # 'get_sun' returns ICRS coords. sun =\",\n \"\\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to\",\n \"= ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument here,\",\n \"Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min\",\n \"def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min\",\n \"observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable during\",\n \": `~astropy.time.Time` The times to compute the constraint observer : `~astroplan.Observer` the observaton\",\n \"dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if\",\n \"to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero\",\n \"target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum\",\n \"= times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True)\",\n \"1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np\",\n \"acceptable separation between Sun and target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min\",\n \"specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours.\",\n \"observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will\",\n \"which month the specified ``targets`` are observable for a specific ``observer``, given the\",\n \"minimum and a maximum of 0.25 Parameters ---------- min : float or `None`\",\n \"ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional\",\n \"Maximum phase (inclusive) on interval [0, 1). Default is one. Examples -------- To\",\n \"`~astropy.time.Time` Array of times on which to test the constraint. targets : {list,\",\n \"times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in\",\n \"to # complex nature of these objects. We make # to simple numpy\",\n \"former calculates the separation in the frame of the moon coord # which\",\n \"outside the range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import\",\n \"float best value cared about (rescales to 1) greater_than_max : 0 or 1\",\n \"= np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException: #\",\n \"as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import\",\n \"these broadcasting operations are relatively slow # but there is potential for huge\",\n \"in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or\",\n \"observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination for\",\n \"of mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional)\",\n \"same length as ``targets`` for whether or not each target is ever observable\",\n \"`None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or\",\n \"objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None,\",\n \"scalar. It also contains metadata entries ``'times'`` (with an array of all the\",\n \"local time: >>> from astroplan import Observer >>> from astroplan.constraints import LocalTimeConstraint >>>\",\n \"computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times. \\\"\\\"\\\" if\",\n \"limit. boolean_contstraint : bool Examples -------- To create a constraint that requires the\",\n \"least supply either a minimum or a \\\" \\\"maximum time.\\\") if self.min is\",\n \"which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times,\",\n \"= observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure =\",\n \"the airmass (``max``) and not the lower limit. Parameters ---------- max : float\",\n \"< min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0\",\n \"on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper\",\n \"a lot by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer,\",\n \"less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg)\",\n \"---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and\",\n \"not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified as\",\n \"The column ``'time observable'`` will also be present if the ``time_range`` is given\",\n \"``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max\",\n \"get sun here, since # it returns the Sun's coordinates in an observer\",\n \"for ``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should also\",\n \"observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar\",\n \"class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ =\",\n \"no maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional\",\n \"str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to\",\n \"Array of booleans of same length as ``times`` for whether or not the\",\n \"range should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as\",\n \"return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be\",\n \"if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to\",\n \"boolean (True for within the limits and False for outside). If False, the\",\n \"with defaults of a minimum of 0.25 and a maximum of 0.65 Parameters\",\n \"the constraints targets : sequence of `~astroplan.Target` The targets on which to apply\",\n \"of the sun below which it is considered to be \\\"night\\\" (inclusive). force_pressure_zero\",\n \"observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun')\",\n \"min : float (optional) Minimum phase (inclusive) on interval [0, 1). Default is\",\n \"that a target is observable, one set per target. These integers are 1-based\",\n \"\\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple\",\n \"moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates the separation\",\n \"moon coord # which is GCRS, and that is what we want. moon_separation\",\n \"((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or min\",\n \"force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly spaced between the two\",\n \"<= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic\",\n \"time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint\",\n \"present if the ``time_range`` is given as a scalar. It also contains metadata\",\n \"``'times'`` (with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and\",\n \"tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey = (targets,)\",\n \"moon_up_mask elif self.min is not None and self.max is not None: mask =\",\n \"should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors\",\n \"time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets`` are always observable throughout ``time_range``\",\n \"dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints =\",\n \"target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s)\",\n \"treat as a SkyCoord object. Accessing the longitude # attribute of the frame\",\n \"to 1 and worst (35) going to 0. For values outside the range,\",\n \"---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and\",\n \"constraints to determine which targets are observable for an observer. \\\"\\\"\\\" from __future__\",\n \"try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude\",\n \"force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination for an array of times\",\n \"to apply the constraints. times : `~astropy.time.Time` The times to compute the constraint.\",\n \"the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min :\",\n \"Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length as ``times``\",\n \"no limit. boolean_contstraint : bool Examples -------- To create a constraint that requires\",\n \"& (solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\"\",\n \"by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table\",\n \"here # moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates\",\n \"on orbital phases between 0.6 and 1.2, for example, you should subtract one\",\n \"# Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates import\",\n \"# use np.bool so shape queries don't cause problems mask = np.bool_(min_time <=\",\n \"as ``targets`` for whether or not each target is ever observable in the\",\n \"Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if not\",\n \"to store expensive calculations for a combination of ``targets`` and ``times`` in a\",\n \"raise ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if\",\n \"observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets)\",\n \"not None: max_time = self.max else: max_time = datetime.time(23, 59, 59) # If\",\n \"= np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2,\",\n \"solar_separation = sun.separation(targets) if self.min is None and self.max is not None: mask\",\n \"default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self,\",\n \"constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation location from\",\n \"(between zero and one), where the ``min_val`` goes to one, and the ``max_val``\",\n \"constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer :\",\n \"described on the interval [0, 1). To constrain observations on orbital phases between\",\n \"float on [0, 1], where 0 is the min altitude and 1 is\",\n \"from .moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__\",\n \"for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs\",\n \"times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on\",\n \"<= separation elif self.min is not None and self.max is not None: mask\",\n \"the distance between the Earth's moon and some targets. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"not None else 0.0 self.max = max if max is not None else\",\n \"None: mask = self.min <= secz elif self.min is not None and self.max\",\n \"at least supply either a minimum or a maximum time.\\\") if self.min is\",\n \"0.5 hours. Returns ------- ever_observable : list List of booleans of same length\",\n \"than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume\",\n \"is approximated by the secant of the zenith angle. .. note:: The ``max``\",\n \"`None` indicates no limit. ephemeris : str, optional Ephemeris to use. If not\",\n \"minimum or a \\\" \\\"maximum time.\\\") if self.min is not None: if not\",\n \"observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max\",\n \"horizon and the corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude =\",\n \"input array ``vals`` to be a score (between zero and one), where the\",\n \"below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>> import\",\n \"eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary\",\n \"is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask =\",\n \"the constraint returns a float on [0, 1], where 0 is the min\",\n \"January maps to 1, February maps to 2, etc. \\\"\\\"\\\" # TODO: This\",\n \"aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure\",\n \"and self.max is not None: mask = (self.max >= illumination) | moon_down_mask elif\",\n \"exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event\",\n \"list of targets times : `~astropy.time.Time` (optional) Array of times on which to\",\n \"or 1 what is returned for ``vals`` above ``max_val``. (in some cases anything\",\n \"target. These integers are 1-based so that January maps to 1, February maps\",\n \">= min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing\",\n \"Constrain the distance between the Galactic plane and some targets. \\\"\\\"\\\" def __init__(self,\",\n \"the observations to targets that are observable between 2016-03-28 and 2016-03-30: >>> from\",\n \"not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified as\",\n \"not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO:\",\n \"from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\",\",\n \"(rescales to 1) less_than_min : 0 or 1 what is returned for ``vals``\",\n \"to reference this combination of ``times`` and ``targets``. Often, we wish to store\",\n \"time_dict : dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times.\",\n \"limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None`\",\n \"must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None,\",\n \"specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is None: raise ValueError(\\\"Cannot\",\n \"constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range =\",\n \"initializer to support the common case for users who care about the upper\",\n \"from astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided #\",\n \"the longitude # attribute of the frame data should be unique and is\",\n \"(inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for solar altitude\",\n \"is not None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else:\",\n \"for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if\",\n \"the observing time to be within certain time limits. An example use case\",\n \"those equal to ``max_val`` equal 1 Examples -------- rescale an array of altitudes\",\n \"(max < 0) or (max > 1): raise ValueError('The minimum of the PhaseConstraint\",\n \": `~astroplan.Observer` the observaton location from which to apply the constraints targets :\",\n \"max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the moon up?\",\n \"not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not\",\n \"and 1 is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min\",\n \"2D with targets along the first index and times along the second. \\\"\\\"\\\"\",\n \"observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from\",\n \"the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum\",\n \"and illumination for an array of times for ``observer``. Cache the result on\",\n \"dict Dictionary containing three key-value pairs. (1) 'times' contains the times for the\",\n \"airmass is approximated by the secant of the zenith angle. .. note:: The\",\n \"and ``'fraction of time observable'``. The column ``'time observable'`` will also be present\",\n \"---------- vals : array-like the values that need to be rescaled to be\",\n \"boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt =\",\n \"max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25\",\n \"Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max =\",\n \"altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask =\",\n \"target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To create a\",\n \"example, you should subtract one from the second number: >>> constraint = PhaseConstraint(binary,\",\n \"on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True,\",\n \"(optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates no limit.\",\n \"time objects, or from observer if self.min is not None: timezone = self.min.tzinfo\",\n \"constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must be described\",\n \"not each target is ever observable in the time range given the constraints.\",\n \"to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints]\",\n \"np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min)\",\n \"['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name\",\n \"45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. ,\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local\",\n \"PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system):\",\n \"hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing aakey\",\n \": dict Dictionary containing three key-value pairs. (1) 'times' contains the times for\",\n \"datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") if self.max is\",\n \"MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's moon and some targets. \\\"\\\"\\\"\",\n \"at least supply either a minimum or a \\\" \\\"maximum time.\\\") if self.min\",\n \"time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to targets\",\n \": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional)\",\n \"targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = []\",\n \"not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod\",\n \"rescaled so that ``vals`` equal to ``max_val`` equal 0 and those equal to\",\n \"targets along the first index and times along the second. Otherwise, we rely\",\n \"def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly\",\n \"observer.pressure = 0 # find solar altitude at these times altaz = observer.altaz(times,\",\n \"(separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\")\",\n \"self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is not None:\",\n \"constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of\",\n \"and those equal to ``max_val`` equal 1 Examples -------- rescale an array of\",\n \"time.\\\") if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits\",\n \"(-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target,\",\n \"array of times for ``observer``. Cache the result on the ``observer`` object. Parameters\",\n \"observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] =\",\n \"must be within' ' the interval [0, 1).') self.min = min if min\",\n \"would be to associate an acceptable time range with a specific observing block.\",\n \"on [0, 1], where 0 is the min altitude and 1 is the\",\n \"(max_val - min_val) below = vals < min_val above = vals > max_val\",\n \"constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list,\",\n \"target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs =\",\n \"np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if\",\n \"elif self.min is not None and self.max is not None: mask = ((self.min\",\n \"altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times,\",\n \"times on which to test the constraint observer : `~astroplan.Observer` The observer who\",\n \"not None: min_time = self.min else: min_time = self.min = datetime.time(0, 0, 0)\",\n \"observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try:\",\n \"Examples -------- To constrain observations on orbital phases between 0.4 and 0.6, >>>\",\n \"the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`\",\n \"constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array\",\n \"If a single (scalar) time, the table will be for a 24 hour\",\n \"\\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'):\",\n \"2D array of float or bool The constraints, with targets along the first\",\n \"else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class\",\n \"\\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint\",\n \"if self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must\",\n \"elif self.max is None and self.min is not None: mask = self.min <=\",\n \"distance between the Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\"\",\n \"fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod\",\n \"`~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def\",\n \"observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation =\",\n \"same length as ``targets`` for whether or not each target is observable in\",\n \"next meridian transit for an array of times for ``targets`` and ``observer``. Cache\",\n \"None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time\",\n \"not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and\",\n \"max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a\",\n \"event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters\",\n \"result with targets along the first index and times along the second. Otherwise,\",\n \"those equal to ``min_val`` equal 1 Examples -------- rescale airmasses to between 0\",\n \"targets.separation(moon) # the former calculates the separation in the frame of the moon\",\n \"PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u >>> binary\",\n \"is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability\",\n \"AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target. .. note:: This can misbehave\",\n \"warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time =\",\n \"secz elif self.min is not None and self.max is not None: mask =\",\n \"mask else: if self.max is None: raise ValueError(\\\"Cannot have a float AirmassConstraint if\",\n \"be a score (between zero and one), where the ``min_val`` goes to one,\",\n \"targets on which to apply the constraints. Returns ------- constraint_result : 2D array\",\n \"__all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\",\",\n \"sets of unique integers representing each month that a target is observable, one\",\n \"Determines if the ``target`` is observable at each time in ``times``, given constraints\",\n \"ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint\",\n \"observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and\",\n \"array of floats between 0 and 1 inclusive rescaled so that ``vals`` equal\",\n \"0 and 1, with the best (60) going to 1 and worst (35)\",\n \"mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None):\",\n \"\\\"maximum time.\\\") if self.min is not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time\",\n \"= max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize\",\n \"not None: mask = self.max >= solar_separation elif self.max is None and self.min\",\n \"times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr,\",\n \"``targets``. The table contains four columns with information about the target and it's\",\n \"observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The\",\n \"np.bool so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <=\",\n \"or subclass System on which to compute the phase. For example, the system\",\n \"best (1) and worst (2.25). All values outside the range should return 0.\",\n \"targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class Parameters\",\n \"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable',\",\n \"targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure\",\n \"disables gridding and re-shapes the coords themselves # prior to evaluating multiple constraints.\",\n \"times and targets against each other if targets is not None: # broadcasting\",\n \"objects. We make # to simple numpy arrays of the same shape and\",\n \"compute_constraint(self, times, observer, targets): # use get_body rather than get sun here, since\",\n \"constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0)\",\n \"None: mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else:\",\n \"altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min :\",\n \"at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert\",\n \"# get timezone from time objects, or from observer if self.min is not\",\n \"A function to determine whether ``targets`` are always observable throughout ``time_range`` given constraints\",\n \"Package from .moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord\",\n \"using standard numpy rules. Returns ------- constraint_result : 1D or 2D array of\",\n \"observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure\",\n \"and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"= get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters here\",\n \"# altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range,\",\n \"2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP\",\n \"hours. Returns ------- observable_months : list List of sets of unique integers representing\",\n \"= np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s =\",\n \"fractional illumination (inclusive). `None` indicates no limit. max : float or `None` (optional)\",\n \"and ``min`` arguments appear in the order (max, min) in this initializer to\",\n \": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict :\",\n \"2, etc. \\\"\\\"\\\" # TODO: This method could be sped up a lot\",\n \": `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``.\",\n \"#5897 is released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris)\",\n \"self.min = min self.max = max def compute_constraint(self, times, observer, targets): separation =\",\n \"Returns ------- observable_months : list List of sets of unique integers representing each\",\n \"sped up a lot by dropping to the trigonometric # altitude calculations. applied_constraints\",\n \"2D array of float or bool The constraints. If 2D with targets along\",\n \"__init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in\",\n \"constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr):\",\n \"three key-value pairs. (1) 'times' contains the times for the computations, (2) 'altaz'\",\n \"List of booleans of same length as ``targets`` for whether or not each\",\n \"the result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of\",\n \"moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum']\",\n \"`~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met between test\",\n \": dict Dictionary containing two key-value pairs. (1) 'times' contains the times for\",\n \"min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): #\",\n \"Force the pressure to zero for solar altitude calculations. This avoids errors in\",\n \"---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target\",\n \"_get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt\",\n \"and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return\",\n \"or `None` (optional) Minimum acceptable fractional illumination (inclusive). `None` indicates no limit. max\",\n \"time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with spacing\",\n \"be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None):\",\n \", 0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals -\",\n \"max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic\",\n \"periodic_event if (min < 0) or (min > 1) or (max < 0)\",\n \"targets): # first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt =\",\n \"Determines which month the specified ``targets`` are observable for a specific ``observer``, given\",\n \"+ '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique\",\n \"times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at\",\n \"to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ----------\",\n \"elif self.max is None and self.min is not None: mask = (self.min <=\",\n \"time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times,\",\n \"up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0\",\n \"to times in some range of phases for a periodic event (e.g.~transiting exoplanets,\",\n \"times is None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if\",\n \"min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive).\",\n \"the PhaseConstraint must be within' ' the interval [0, 1).') self.min = min\",\n \"for an array of times for ``targets`` and ``observer``. Cache the result on\",\n \"initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25\",\n \"import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times\",\n \"Array of times on which to test the constraint observer : `~astroplan.Observer` The\",\n \"if self.min is None and self.max is not None: mask = self.max >=\",\n \"with defaults of no minimum and a maximum of 0.25 Parameters ---------- min\",\n \"observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ----------\",\n \"between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer,\",\n \"np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod\",\n \"mask = self.max >= solar_separation elif self.max is None and self.min is not\",\n \"SkyCoord object. Accessing the longitude # attribute of the frame data should be\",\n \"from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as\",\n \"= (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times,\",\n \"backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\"\",\n \"phase must be described on the interval [0, 1). To constrain observations on\",\n \"for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time()\",\n \"def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a\",\n \"self.boolean_constraint: if self.min is None and self.max is not None: mask = secz\",\n \"of unique integers representing each month that a target is observable, one set\",\n \"None.\\\") else: mx = self.max mi = 1 if self.min is None else\",\n \"for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None,\",\n \"def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical twilights (-18 degrees).\",\n \"higher than ``max_val`` should also return one, in some cases it should return\",\n \"1 is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is\",\n \"target. In the current implementation the airmass is approximated by the secant of\",\n \"all observing blocks are valid over the time limits used in calls to\",\n \"hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is\",\n \">= 0 illumination = cached_moon['illum'] if self.min is None and self.max is not\",\n \"times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) colnames =\",\n \"from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\",\",\n \"between 0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal\",\n \"SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets,\",\n \"equal to ``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples\",\n \"= observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az\",\n \"For values outside the range, the rescale should return 0 below 35 and\",\n \"and the corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude\",\n \"apply the constraints targets : sequence of `~astroplan.Target` The targets on which to\",\n \"cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not None: mask\",\n \"self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument\",\n \"would result from # broadcasting times and targets against each other if targets\",\n \"`is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest\",\n \"`~astropy.time.Time` Array of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord`\",\n \"(min < 0) or (min > 1) or (max < 0) or (max\",\n \"acceptable separation between moon and target (inclusive). `None` indicates no limit. max :\",\n \"or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on\",\n \"= sun.separation(targets) if self.min is None and self.max is not None: mask =\",\n \"is not None: mask = self.max >= moon_separation elif self.max is None and\",\n \"times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint:\",\n \"minimum or a maximum time.\\\") if self.min is not None: if not isinstance(self.min,\",\n \": `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met between\",\n \"to be rescaled to be between 0 and 1 min_val : float worst\",\n \"each other if targets is not None: # broadcasting times v targets is\",\n \"(True for within the limits and False for outside). If False, the constraint\",\n \"else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class\",\n \"not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\")\",\n \"the lower limit. Parameters ---------- max : float or `None` Maximum airmass of\",\n \"0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0\",\n \"illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer,\",\n \"self.min is not None and self.max is not None: mask = (self.min <=\",\n \"if self.min is None and self.max is not None: mask = (self.max >=\",\n \"]) \\\"\\\"\\\" rescaled = (vals - max_val) / (min_val - max_val) below =\",\n \"Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta\",\n \"min_time) or (times.datetime.time() <= max_time)) return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time\",\n \"``min_val`` equal 1 Examples -------- rescale airmasses to between 0 and 1, with\",\n \"max if self.min is None and self.max is None: raise ValueError(\\\"You must at\",\n \"grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters\",\n \"if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination =\",\n \"from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1,\",\n \"\\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize\",\n \"observer if self.min is not None: timezone = self.min.tzinfo elif self.max is not\",\n \"the constraint is treated as a boolean (True for within the limits and\",\n \"times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system :\",\n \"If 2D with targets along the first index and times along the second.\",\n \"``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a\",\n \"min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable\",\n \"values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint):\",\n \"calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) #\",\n \"mask = self.max >= moon_separation elif self.max is None and self.min is not\",\n \"by default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod\",\n \"in times.datetime]) except BaseException: # use np.bool so shape queries don't cause problems\",\n \"None: mask = (self.min <= illumination) & moon_up_mask elif self.min is not None\",\n \"aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0\",\n \"have a float AirmassConstraint if max is None.\\\") else: mx = self.max mi\",\n \"if True, grids the constraint result with targets along the first index and\",\n \"current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether\",\n \"Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local\",\n \"is None and self.min is not None: mask = self.min <= separation elif\",\n \"result on the ``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times\",\n \"not None: mask = (self.min <= secz) & (secz <= self.max) else: raise\",\n \"ephemeris def compute_constraint(self, times, observer, targets): # removed the location argument here, which\",\n \"self.max) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask\",\n \"observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`,\",\n \"less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. ,\",\n \"`~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None`\",\n \"target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude\",\n \"from targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object.\",\n \"__init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional)\",\n \"# doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ])\",\n \"targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times\",\n \"integers representing each month that a target is observable, one set per target.\",\n \"not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin'\",\n \"`None` Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint :\",\n \"= [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr =\",\n \"``'always observable'``, and ``'fraction of time observable'``. The column ``'time observable'`` will also\",\n \"moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order matters\",\n \"moon illumination for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {}\",\n \"times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for\",\n \"time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range``\",\n \"an input array ``vals`` to be a score (between zero and one), where\",\n \"(targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer,\",\n \"self.max is None and self.min is not None: mask = self.min <= secz\",\n \"moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None and\",\n \"for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]])\",\n \"for this class would be to associate an acceptable time range with a\",\n \"airmass of a target. In the current implementation the airmass is approximated by\",\n \"by default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris def\",\n \"float best value cared about (rescales to 1) less_than_min : 0 or 1\",\n \"'_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache:\",\n \"\\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\",\",\n \"moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`\",\n \"goes to zero. Parameters ---------- vals : array-like the values that need to\",\n \"is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def\",\n \"mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some range of phases\",\n \"to zero. Parameters ---------- vals : array-like the values that need to be\",\n \"months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a\",\n \"limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\"\",\n \"force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary\",\n \"mask = self.min <= secz elif self.min is not None and self.max is\",\n \"@classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of\",\n \"timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and 04:08 local Hawaiian time >>>\",\n \"< 0) or (min > 1) or (max < 0) or (max >\",\n \"outside). If False, the constraint returns a float on [0, 1], where 0\",\n \"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None,\",\n \"by dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints\",\n \"support the common case for users who care about the upper limit on\",\n \"note:: This can misbehave if you try to constrain negative altitudes, as the\",\n \"observations to times in some range of phases for a periodic event (e.g.~transiting\",\n \"max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun\",\n \"object. Parameters ---------- times : `~astropy.time.Time` Array of times on which to test\",\n \"``max_val`` equal 0 and those equal to ``min_val`` equal 1 Examples -------- rescale\",\n \"to find the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1])\",\n \"LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max if self.min is None\",\n \"secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System\",\n \"max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates\",\n \": `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system\",\n \"`~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0\",\n \"or `None` Maximum airmass of the target. `None` indicates no limit. min :\",\n \"get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but there is\",\n \"sequence of `~astroplan.Target` The targets on which to apply the constraints. times :\",\n \"max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min = min\",\n \"Actually do the real work of computing the constraint. Subclasses override this. Parameters\",\n \"targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if\",\n \"so the separation is as-seen # by the observer. # 'get_sun' returns ICRS\",\n \"between Sun and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or\",\n \"same as targets.separation(moon) # the former calculates the separation in the frame of\",\n \"in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`\",\n \"or 2D array of float or bool The constraints. If 2D with targets\",\n \"`~numpy.ndarray` Array of booleans of same length as ``times`` for whether or not\",\n \"observable for an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals) #\",\n \"``times`` and ``targets``. Often, we wish to store expensive calculations for a combination\",\n \"we wish to store expensive calculations for a combination of ``targets`` and ``times``\",\n \"Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and 04:08 local Hawaiian time\",\n \"targets against each other if targets is not None: # broadcasting times v\",\n \"tuple A hashable tuple for use as a cache key \\\"\\\"\\\" # make\",\n \"targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity`\",\n \"pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache =\",\n \"on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude\",\n \"observer, targets): # use get_body rather than get sun here, since # it\",\n \"---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max\",\n \"and not the lower limit. Parameters ---------- max : float or `None` Maximum\",\n \">>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\"\",\n \"during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints\",\n \"here, since # it returns the Sun's coordinates in an observer # centred\",\n \"= (self.min <= secz) & (secz <= self.max) else: raise ValueError(\\\"No max and/or\",\n \"(self.max >= illumination) | moon_down_mask elif self.max is None and self.min is not\",\n \"so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time)\",\n \"mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in times.datetime])\",\n \"0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information\",\n \"self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None,\",\n \"> 1): raise ValueError('The minimum of the PhaseConstraint must be within' ' the\",\n \"negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target\",\n \"fractional illumination of the Earth's moon. Constraint is also satisfied if the Moon\",\n \"to 2, etc. \\\"\\\"\\\" # TODO: This method could be sped up a\",\n \"one. Examples -------- To constrain observations on orbital phases between 0.4 and 0.6,\",\n \"is not None: max_time = self.max else: max_time = datetime.time(23, 59, 59) #\",\n \">>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint\",\n \"`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer who\",\n \"> self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min) |\",\n \"is returned for ``vals`` above ``max_val``. (in some cases anything higher than ``max_val``\",\n \"indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65,\",\n \"Returns ------- ever_observable : list List of booleans of same length as ``targets``\",\n \"booleans of same length as ``times`` for whether or not the target is\",\n \"``target`` at times linearly spaced between the two times in ``time_range`` with grid\",\n \"if timezone is None: timezone = observer.timezone if self.min is not None: min_time\",\n \": `~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}\",\n \"raise ValueError(\\\"Cannot have a float AirmassConstraint if max is None.\\\") else: mx =\",\n \"set per target. These integers are 1-based so that January maps to 1,\",\n \"aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey]\",\n \"2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length as\",\n \"are observable between 23:50 and 04:08 local time: >>> from astroplan import Observer\",\n \"\\\" \\\"maximum time.\\\") if self.min is not None: if not isinstance(self.min, Time): raise\",\n \"the constraint result with targets along the first index and times along the\",\n \"self.max is not None: mask = self.max >= moon_separation elif self.max is None\",\n \"np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0]\",\n \"True, the constraint is treated as a boolean (True for within the limits\",\n \"`~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations\",\n \"with a specific observing block. This can be useful if not all observing\",\n \"illumination for an array of times for ``observer``. Cache the result on the\",\n \"indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None,\",\n \": `~astropy.time.Time` (optional) Lower and upper bounds on time sequence If ``time_range`` is\",\n \"np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times\",\n \"return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals``\",\n \"limit. \\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self, times, observer, targets):\",\n \"test the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure\",\n \"<= max_time for t in times.datetime]) except BaseException: # use np.bool so shape\",\n \"Target or list of targets. observer : `~astroplan.Observer` The observer who has constraints\",\n \"isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") if\",\n \"(inclusive) on interval [0, 1). Default is one. Examples -------- To constrain observations\",\n \"get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\",\",\n \"upper bounds on time sequence If ``time_range`` is not specified, defaults to current\",\n \"nighttime as time between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod\",\n \"2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import Time\",\n \"------- event_observable : `~numpy.ndarray` Array of booleans of same length as ``times`` for\",\n \"Target times : `~astropy.time.Time` (optional) Array of mid-event times on which to test\",\n \">= illumination) | moon_down_mask elif self.max is None and self.min is not None:\",\n \"sequence If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution :\",\n \"- see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which targets are observable\",\n \": `~astropy.time.Time` Array of times on which to test the constraint observer :\",\n \"one), where the ``max_val`` goes to one, and the ``min_val`` goes to zero.\",\n \"contains four columns with information about the target and it's observability: ``'target name'``,\",\n \"max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable\",\n \"max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a\",\n \"rescales an input array ``vals`` to be a score (between zero and one),\",\n \"targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times\",\n \"`~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint result with\",\n \"(optional) Array of times on which to test the constraint time_range : `~astropy.time.Time`\",\n \"contains the moon illumination for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache\",\n \"day: if min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time\",\n \"force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next\",\n \"the interval [0, 1). To constrain observations on orbital phases between 0.6 and\",\n \"given constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list\",\n \"a key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'):\",\n \"time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times,\",\n \"and target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max =\",\n \"\\\"\\\"\\\" Determines if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list``\",\n \"to 0) max_val : float best value cared about (rescales to 1) greater_than_max\",\n \"\\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward compatibility\",\n \"lot by dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets,\",\n \"1, with the best (60) going to 1 and worst (35) going to\",\n \"and no maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable\",\n \"self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets)\",\n \"Consider nighttime as time between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs)\",\n \"midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for\",\n \"ValueError(\\\"Cannot have a float AirmassConstraint if max is None.\\\") else: mx = self.max\",\n \"0 or 1 what is returned for ``vals`` below ``min_val``. (in some cases\",\n \"data should be unique and is # quicker than accessing the ra attribute.\",\n \"hashing aakey = _make_cache_key(times, targets) if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times,\",\n \"self.min is not None: timezone = self.min.tzinfo elif self.max is not None: timezone\",\n \"Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min\",\n \"target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of\",\n \"contains the corresponding alt/az coordinates at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'):\",\n \"Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the\",\n \"# make hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat\",\n \"04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min\",\n \"(1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[...,\",\n \"float or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit.\",\n \"= np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0)\",\n \"of times for ``observer``. Cache the result on the ``observer`` object. Parameters ----------\",\n \"targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time`\",\n \"(min > 1) or (max < 0) or (max > 1): raise ValueError('The\",\n \"vals < min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] =\",\n \">>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60)\",\n \"[0, 1). To constrain observations on orbital phases between 0.6 and 1.2, for\",\n \"that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints\",\n \"with targets along the first index and times along the second. Otherwise, we\",\n \"= self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone is\",\n \"time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable during ``time_range`` given constraints\",\n \"observer.pressure observer.pressure = 0 # find solar altitude at these times altaz =\",\n \"as a boolean (True for within the limits and False for outside). If\",\n \"``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict\",\n \"Minimum airmass of the target. `None` indicates no limit. boolean_contstraint : bool Examples\",\n \"= max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is\",\n \"1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"``max`` and ``min`` arguments appear in the order (max, min) in this initializer\",\n \"(optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates no limit.\",\n \"frame of the moon coord # which is GCRS, and that is what\",\n \"PhaseConstraint must be within' ' the interval [0, 1).') self.min = min if\",\n \"on an ``observer``` object. This routine will provide an appropriate, hashable, key to\",\n \"altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] =\",\n \"max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or\",\n \"the second. Otherwise, we rely on broadcasting the shapes together using standard numpy\",\n \"which to apply the constraints targets : sequence of `~astroplan.Target` The targets on\",\n \"constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is not\",\n \"constraint returns a float on [0, 1], where 0 is the min altitude\",\n \"else: self.min = min if max is None: self.max = 90*u.deg else: self.max\",\n \"times, observer, targets): \\\"\\\"\\\" Actually do the real work of computing the constraint.\",\n \"time between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls,\",\n \"is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table\",\n \"not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 #\",\n \": `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use\",\n \"supply either a minimum or a \\\" \\\"maximum time.\\\") if self.min is not\",\n \"constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for ``N``\",\n \"times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray`\",\n \"make a tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException:\",\n \"'_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing aakey =\",\n \"time in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ----------\",\n \"\\\"\\\"\\\" rescales an input array ``vals`` to be a score (between zero and\",\n \"If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity`\",\n \"observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list\",\n \"def compute_constraint(self, times, observer, targets): # use get_body rather than get sun here,\",\n \"so that January maps to 1, February maps to 2, etc. \\\"\\\"\\\" #\",\n \"min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times\",\n \"datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between\",\n \"constraints. Returns ------- constraint_result : 2D array of float or bool The constraints,\",\n \"to ``max_val`` equal 1 Examples -------- rescale an array of altitudes to be\",\n \"whether or not the target is ever observable at each time, given the\",\n \"of ``times`` and ``targets``. Often, we wish to store expensive calculations for a\",\n \"phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase\",\n \"0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals - min_val)\",\n \"moon_separation elif self.min is not None and self.max is not None: mask =\",\n \"of `~astroplan.Target` The targets on which to apply the constraints. Returns ------- constraint_result\",\n \"between the Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters\",\n \"distance between the Earth's moon and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None,\",\n \"targets is not None: # broadcasting times v targets is slow due to\",\n \"targets.shape else: # assume targets is a string. targkey = (targets,) except BaseException:\",\n \"which it is considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force\",\n \"Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds\",\n \"tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an\",\n \"min self.max = max if self.min is None and self.max is None: raise\",\n \"integers are 1-based so that January maps to 1, February maps to 2,\",\n \"targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets =\",\n \"self.min is not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be\",\n \"which to apply the constraints. times : `~astropy.time.Time` The times to compute the\",\n \"airmass (``max``) and not the lower limit. Parameters ---------- max : float or\",\n \"one), where the ``min_val`` goes to one, and the ``max_val`` goes to zero.\",\n \"for backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year) +\",\n \"the horizon and the corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude\",\n \"computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times\",\n \"the range, the rescale should return 0 below 35 and 1 above 60.\",\n \"2\\\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None,\",\n \"``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times\",\n \"in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\"\",\n \"TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer,\",\n \"booleans of same length as ``targets`` for whether or not each target is\",\n \"``target`` is observable at each time in ``times``, given constraints in ``constraints`` for\",\n \"try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time) for t in\",\n \"standard numpy rules. Returns ------- constraint_result : 1D or 2D array of float\",\n \"length as ``targets`` for whether or not each target is observable in the\",\n \"one, and the ``min_val`` goes to zero. Parameters ---------- vals : array-like the\",\n \"not None and self.max is not None: mask = (self.min <= secz) &\",\n \"moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains the times\",\n \"make sure the output has the same shape as would result from #\",\n \">= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None,\",\n \"try: timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar timekey\",\n \"= self.max else: max_time = datetime.time(23, 59, 59) # If time limits occur\",\n \"get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally:\",\n \"1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the order\",\n \"moon. Constraint is also satisfied if the Moon has set. \\\"\\\"\\\" def __init__(self,\",\n \"= LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max if self.min is\",\n \"and egress times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable\",\n \"`~astroplan.Observer` the observaton location from which to apply the constraints targets : sequence\",\n \"ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max\",\n \"if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for a\",\n \"distance between the Galactic plane and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None):\",\n \"targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time`\",\n \"``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples -------- rescale\",\n \"timezone = None # get timezone from time objects, or from observer if\",\n \"mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in\",\n \"`~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target\",\n \"\\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self,\",\n \"tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException: # must\",\n \"returns a float on [0, 1], where 0 is the min altitude and\",\n \"targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool\",\n \"cached_moon['illum'] if self.min is None and self.max is not None: mask = (self.max\",\n \"output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the\",\n \"frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum\",\n \"the limits and False for outside). If False, the constraint returns a float\",\n \"# make sure the output has the same shape as would result from\",\n \"= self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint):\",\n \"= (self.max >= illumination) | moon_down_mask elif self.max is None and self.min is\",\n \": `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max : `~datetime.time`\",\n \"\\\"\\\"\\\" Constrain the distance between the Galactic plane and some targets. \\\"\\\"\\\" def\",\n \"not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for hashing\",\n \"needed for backward compatibility _current_year_time_range = Time( # needed for backward compatibility [str(_current_year)\",\n \"return result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the real\",\n \"moon and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ----------\",\n \"a minimum of 0.25 and a maximum of 0.65 Parameters ---------- min :\",\n \"`None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates no\",\n \"Parameters ---------- times : `~astropy.time.Time` Array of times on which to test the\",\n \"self.max is None and self.min is not None: mask = self.min <= separation\",\n \"accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets\",\n \"self.max >= separation elif self.max is None and self.min is not None: mask\",\n \"and self.min is not None: mask = self.min <= separation elif self.min is\",\n \"((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No max\",\n \"= self.min = datetime.time(0, 0, 0) if self.max is not None: max_time =\",\n \"self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary eclipse.\",\n \"float or bool The constraints. If 2D with targets along the first index\",\n \"1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2,\",\n \"'times' contains the times for the computations, (2) 'altaz' contains the corresponding alt/az\",\n \"values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\"\",\n \"has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict\",\n \"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None,\",\n \"`~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'):\",\n \"(max, min) in this initializer to support the common case for users who\",\n \"= ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with\",\n \"`~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates no limit.\",\n \"airmass of the target. `None` indicates no limit. min : float or `None`\",\n \"np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names, ever_obs,\",\n \"constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets,\",\n \"= self.max >= solar_separation elif self.max is None and self.min is not None:\",\n \"or `None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates\",\n \"min specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is None: raise\",\n \"\\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year\",\n \"return zero) Returns ------- array of floats between 0 and 1 inclusive rescaled\",\n \"constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False):\",\n \"observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude\",\n \"``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional)\",\n \"targets): \\\"\\\"\\\" Calculate next meridian transit for an array of times for ``targets``\",\n \"it should return zero) Returns ------- array of floats between 0 and 1\",\n \"twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider\",\n \"BaseException: # use np.bool so shape queries don't cause problems mask = np.bool_(min_time\",\n \"range with a specific observing block. This can be useful if not all\",\n \"def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None`\",\n \"(times.jd,) # make hashable thing from targets coords try: if hasattr(targets, 'frame'): #\",\n \"compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase\",\n \"the correct shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a =\",\n \"default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris @classmethod def\",\n \"library from abc import ABCMeta, abstractmethod import datetime import time import warnings #\",\n \"to 0. For values outside the range, the rescale should return 0 below\",\n \"as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity`\",\n \"spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer`` object. Parameters ----------\",\n \"\\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no\",\n \"to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress\",\n \"ever_obs, always_obs, frac_obs]) if times is None and time_range is not None: times\",\n \"mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun and some targets.\",\n \"constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified\",\n \"t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min\",\n \"= vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def\",\n \">>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max if self.min\",\n \"The targets on which to apply the constraints. Returns ------- constraint_result : 2D\",\n \"who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time`\",\n \"# which is GCRS, and that is what we want. moon_separation = moon.separation(targets)\",\n \"---------- times : `~astropy.time.Time` Array of times on which to test the constraint\",\n \"is None and self.max is not None: mask = self.max >= moon_separation elif\",\n \"= _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure =\",\n \"\\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is\",\n \"\\\"\\\"\\\" Actually do the real work of computing the constraint. Subclasses override this.\",\n \"by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List of\",\n \"self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer,\",\n \"under a 3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints\",\n \"= self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is not\",\n \"A hashable tuple for use as a cache key \\\"\\\"\\\" # make a\",\n \"be specified as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone = None\",\n \"to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns\",\n \"'-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to reference this\",\n \"longitude # attribute of the frame data should be unique and is #\",\n \"-------- Constrain the observations to targets that are observable between 2016-03-28 and 2016-03-30:\",\n \"= Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint =\",\n \"table with information about observability for all the ``targets`` over the requested ``time_range``,\",\n \"ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a\",\n \"separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask\",\n \"(targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az\",\n \"acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min =\",\n \"class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Earth's moon and some targets.\",\n \"each time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints]\",\n \"less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales\",\n \"sun below which it is considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool\",\n \"mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic plane and some\",\n \"returns the Sun's coordinates in an observer # centred frame, so the separation\",\n \"is not None: # broadcasting times v targets is slow due to #\",\n \"and self.max is not None: mask = ((self.min <= illumination) & (illumination <=\",\n \"None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified as \\\"\",\n \"of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the altitude of the target.\",\n \"`~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple A hashable\",\n \"don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time\",\n \"observer, targets): \\\"\\\"\\\" Actually do the real work of computing the constraint. Subclasses\",\n \"Constrain the fractional illumination of the Earth's moon. Constraint is also satisfied if\",\n \"altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains the times\",\n \"self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone is None:\",\n \"targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min\",\n \"Minimum phase (inclusive) on interval [0, 1). Default is zero. max : float\",\n \"broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result : 1D\",\n \"(optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. \\\"\\\"\\\"\",\n \"constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be\",\n \"value (rescales to 0) max_val : float best value cared about (rescales to\",\n \"self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times,\",\n \"array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled =\",\n \"``targets`` and ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times\",\n \"targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer`\",\n \"not the target is ever observable at each time, given the constraints. \\\"\\\"\\\"\",\n \"u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6)\",\n \"1-based so that January maps to 1, February maps to 2, etc. \\\"\\\"\\\"\",\n \"periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For\",\n \"of a target. In the current implementation the airmass is approximated by the\",\n \"= [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped\",\n \"time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence.\",\n \"coords themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure we\",\n \": bool Examples -------- To create a constraint that requires the airmass be\",\n \"and ``targets``. Often, we wish to store expensive calculations for a combination of\",\n \"finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\"\",\n \"------- constraint_result : 1D or 2D array of float or bool The constraints.\",\n \"\\\"\\\"\\\" if times is None and time_range is not None: times = time_grid_from_range(time_range,\",\n \"observaton location from which to apply the constraints targets : sequence of `~astroplan.Target`\",\n \"Consider nighttime as time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs)\",\n \"the frame of the moon coord # which is GCRS, and that is\",\n \"moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min\",\n \"or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints``\",\n \"'__len__'): constraints = [constraints] if times is not None: applied_constraints = [constraint(observer, target,\",\n \"not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz\",\n \"of the target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To\",\n \"np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which\",\n \"import numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon import\",\n \"is None else self.min # values below 1 should be disregarded return min_best_rescale(secz,\",\n \"data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is not None:\",\n \"None and self.max is None: raise ValueError(\\\"You must at least supply either a\",\n \"be a score (between zero and one), where the ``max_val`` goes to one,\",\n \"= max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times,\",\n \"or (max > 1): raise ValueError('The minimum of the PhaseConstraint must be within'\",\n \": list List of booleans of same length as ``targets`` for whether or\",\n \"min=0.4, max=0.6) The minimum and maximum phase must be described on the interval\",\n \"will be for a 24 hour period centered on that time. time_grid_resolution :\",\n \"return cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a\",\n \"None: max_time = self.max else: max_time = datetime.time(23, 59, 59) # If time\",\n \"`~astroplan.Observer` the observation location from which to apply the constraints targets : sequence\",\n \"the distance between the Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None):\",\n \"who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns -------\",\n \"None: raise ValueError(\\\"You must at least supply either a minimum or a maximum\",\n \"the current implementation the airmass is approximated by the secant of the zenith\",\n \"if self.max is None else self.max mask = np.logical_and(times > min_time, times <\",\n \"Parameters ---------- observer : `~astroplan.Observer` the observation location from which to apply the\",\n \"import Time import astropy.units as u from astropy.coordinates import get_body, get_sun, get_moon, Galactic,\",\n \"`None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer,\",\n \"Default is 0.5 hours. Returns ------- ever_observable : list List of booleans of\",\n \"**kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical twilights\",\n \"solar altitude calculations. This avoids errors in the altitude of the Sun that\",\n \"= [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else:\",\n \"straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <= max_time)\",\n \"to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache:\",\n \"the constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS\",\n \"on broadcasting the shapes together using standard numpy rules. Returns ------- constraint_result :\",\n \"self.min <= alt uppermask = alt <= self.max return lowermask & uppermask else:\",\n \"__init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint\",\n \"but it is needed until astropy PR #5897 is released # which should\",\n \"to future editors - the order matters here # moon.separation(targets) is NOT the\",\n \"to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min\",\n \"# to simple numpy arrays of the same shape and # broadcast these\",\n \"specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between\",\n \"import PeriodicEvent >>> from astropy.time import Time >>> import astropy.units as u >>>\",\n \"four columns with information about the target and it's observability: ``'target name'``, ``'ever\",\n \"# must be scalar timekey = (times.jd,) # make hashable thing from targets\",\n \"astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes = np.array([20, 30,\",\n \"separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list List\",\n \"return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the\",\n \"observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination,\",\n \"max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a\",\n \"ValueError(\\\"You must at least supply either a minimum or a maximum time.\\\") if\",\n \"not None: mask = secz <= self.max elif self.max is None and self.min\",\n \"datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") def compute_constraint(self, times,\",\n \"0.0 self.max = max if max is not None else 1.0 def compute_constraint(self,\",\n \"<gh_stars>100-1000 # Licensed under a 3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\"\",\n \"result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\"\",\n \"first index and times along the second. \\\"\\\"\\\" # Should be implemented on\",\n \"(``max``) and not the lower limit. Parameters ---------- max : float or `None`\",\n \"\\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is None: raise ValueError(\\\"Cannot have a\",\n \"not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz\",\n \"(absolute_import, division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import\",\n \"time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None`\",\n \"and self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation <=\",\n \"GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic plane and some targets. \\\"\\\"\\\"\",\n \"supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False\",\n \"equal 0 and those equal to ``min_val`` equal 1 Examples -------- rescale airmasses\",\n \"(inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates\",\n \"alt/az coordinates at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {}\",\n \"``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None`\",\n \"min : float or `None` Minimum airmass of the target. `None` indicates no\",\n \"min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score\",\n \"if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False)\",\n \"for ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times :\",\n \"constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array\",\n \"contains the times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates\",\n \"the constraint observer : `~astroplan.Observer` the observaton location from which to apply the\",\n \"a tuple from times try: timekey = tuple(times.jd) + times.shape except BaseException: #\",\n \"if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints\",\n \"between moon and target (inclusive). `None` indicates no limit. ephemeris : str, optional\",\n \"- the order matters here # moon.separation(targets) is NOT the same as targets.separation(moon)\",\n \"min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time`\",\n \"np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result\",\n \"must at least supply either a minimum or a maximum time.\\\") if self.min\",\n \"# TODO: This method could be sped up a lot by dropping to\",\n \"def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no\",\n \"observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object):\",\n \"a table with information about observability for all the ``targets`` over the requested\",\n \"inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and those equal\",\n \"self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask = np.logical_and(times\",\n \"AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max = max\",\n \"Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] )\",\n \"\\\"\\\"\\\" Creates a table with information about observability for all the ``targets`` over\",\n \"and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min :\",\n \"and one), where the ``max_val`` goes to one, and the ``min_val`` goes to\",\n \"\\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward\",\n \"as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape:\",\n \"calculates the separation in the frame of the moon coord # which is\",\n \"altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) #\",\n \"`None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris :\",\n \"up a lot by dropping to the trigonometric # altitude calculations. applied_constraints =\",\n \"\\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range,\",\n \"on which to apply the constraints. Returns ------- constraint_result : 2D array of\",\n \"/ (max_val - min_val) below = vals < min_val above = vals >\",\n \"user # disables gridding and re-shapes the coords themselves # prior to evaluating\",\n \"min self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if\",\n \"to times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system\",\n \"get_body rather than get sun here, since # it returns the Sun's coordinates\",\n \"time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class Parameters ---------- observer :\",\n \"if targets.isscalar: # ensure we have a (1, 1) shape coord targets =\",\n \"within certain time limits. An example use case for this class would be\",\n \"= observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer,\",\n \"Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters\",\n \"use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set\",\n \"= secz <= self.max elif self.max is None and self.min is not None:\",\n \"NOT the same as targets.separation(moon) # the former calculates the separation in the\",\n \"= TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max if self.min is None\",\n \"ValueError(\\\"You must at least supply either a minimum or a \\\" \\\"maximum time.\\\")\",\n \"0, 0) if self.max is not None: max_time = self.max else: max_time =\",\n \"= self.min <= secz elif self.min is not None and self.max is not\",\n \"and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets,\",\n \": sequence of `~astroplan.Target` The targets on which to apply the constraints. times\",\n \"= True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in\",\n \"{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets times : `~astropy.time.Time` (optional) Array\",\n \"59, 59) # If time limits occur on same day: if min_time <\",\n \"needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times,\",\n \"best value cared about (rescales to 1) less_than_min : 0 or 1 what\",\n \"``vals`` below ``min_val``. (in some cases anything less than ``min_val`` should also return\",\n \"and self.min is not None: mask = self.min <= solar_separation elif self.min is\",\n \"\\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun\",\n \"is not None and self.max is not None: mask = (self.min <= secz)\",\n \"< max_time: try: mask = np.array([min_time <= t.time() <= max_time for t in\",\n \"time limits occur on same day: if min_time < max_time: try: mask =\",\n \"import Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>>\",\n \"hours. Returns ------- ever_observable : list List of booleans of same length as\",\n \"alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt\",\n \"times for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those\",\n \"centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine\",\n \"``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing\",\n \"(phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets,\",\n \"where the ``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters\",\n \"treated as a boolean (True for within the limits and False for outside).\",\n \"limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples\",\n \"`~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None`\",\n \"range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def\",\n \"time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids\",\n \"grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow #\",\n \"\\\"\\\"\\\" Constrain the airmass of a target. In the current implementation the airmass\",\n \"None and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time\",\n \"(2) 'altaz' contains the corresponding alt/az coordinates at those times. \\\"\\\"\\\" if not\",\n \"targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask =\",\n \"of the frame data should be unique and is # quicker than accessing\",\n \".target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\",\",\n \"the same shape as would result from # broadcasting times and targets against\",\n \"# Package from .moon import moon_illumination from .utils import time_grid_from_range from .target import\",\n \"is released # which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) #\",\n \"__call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this\",\n \"exoplanet system. min : float (optional) Minimum phase (inclusive) on interval [0, 1).\",\n \"with defaults of a minimum of 0.65 and no maximum Parameters ---------- min\",\n \"finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\"\",\n \"mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the\",\n \"for whether or not each target is ever observable in the time range\",\n \"table import numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon\",\n \"is None and self.max is None: raise ValueError(\\\"You must at least supply either\",\n \"on same day: if min_time < max_time: try: mask = np.array([min_time <= t.time()\",\n \"phases between 0.6 and 1.2, for example, you should subtract one from the\",\n \"the pressure to zero for solar altitude calculations. This avoids errors in the\",\n \"below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude :\",\n \"between 0 and 1, with the best (1) and worst (2.25). All values\",\n \"of time observable'``. The column ``'time observable'`` will also be present if the\",\n \"def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key to reference this combination of\",\n \"other if targets is not None: # broadcasting times v targets is slow\",\n \"observable_months : list List of sets of unique integers representing each month that\",\n \"not None: timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo\",\n \"make hashable thing from targets coords try: if hasattr(targets, 'frame'): # treat as\",\n \"not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of\",\n \"to determine which targets are observable for an observer. \\\"\\\"\\\" from __future__ import\",\n \"the ``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters ----------\",\n \"Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\")\",\n \"times, observer, targets): timezone = None # get timezone from time objects, or\",\n \"be to associate an acceptable time range with a specific observing block. This\",\n \"min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon and target\",\n \"not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution,\",\n \"None: mask = secz <= self.max elif self.max is None and self.min is\",\n \"None and self.max is not None: mask = self.max >= solar_separation elif self.max\",\n \"block. This can be useful if not all observing blocks are valid over\",\n \"import as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range from\",\n \"be described on the interval [0, 1). To constrain observations on orbital phases\",\n \"compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if\",\n \"an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing\",\n \"period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase must\",\n \"small <1 deg # innacuracies, but it is needed until astropy PR #5897\",\n \"for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets,\",\n \"phase (inclusive) on interval [0, 1). Default is one. Examples -------- To constrain\",\n \"{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower\",\n \"\\\" \\\"astropy.time.Time objects.\\\") if self.max is not None: if not isinstance(self.max, Time): raise\",\n \"observability for all the ``targets`` over the requested ``time_range``, given the constraints in\",\n \"the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction\",\n \"name', 'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name for\",\n \"time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1)\",\n \"Standard library from abc import ABCMeta, abstractmethod import datetime import time import warnings\",\n \"# doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\"\",\n \"corresponding alt/az coordinates at those times and (3) contains the moon illumination for\",\n \"= self.max >= moon_separation elif self.max is None and self.min is not None:\",\n \"= Time(\\\"1950-01-01T00:00:00\\\") if self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max\",\n \": `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain\",\n \"return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table\",\n \"def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether\",\n \"LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> #\",\n \"\\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\",\",\n \"sequence, with spacing ``time_resolution``. This will be passed as the first argument into\",\n \"return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for\",\n \"self.max is None: raise ValueError(\\\"Cannot have a float AirmassConstraint if max is None.\\\")\",\n \"the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation location\",\n \"minimum and maximum phase must be described on the interval [0, 1). To\",\n \"mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary eclipse. \\\"\\\"\\\" def\",\n \"-------- To constrain observations on orbital phases between 0.4 and 0.6, >>> from\",\n \"self.max), (phase >= self.min) | (phase <= self.max)) return mask def is_always_observable(constraints, observer,\",\n \": `~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events, with\",\n \"0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1)\",\n \"the altitude of the target. .. note:: This can misbehave if you try\",\n \"\\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no\",\n \"and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints =\",\n \"targets on which to apply the constraints. times : `~astropy.time.Time` The times to\",\n \"not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") def\",\n \"limits occur on same day: if min_time < max_time: try: mask = np.array([min_time\",\n \"not None: mask = self.max >= separation elif self.max is None and self.min\",\n \"orbital phases between 0.6 and 1.2, for example, you should subtract one from\",\n \"and the ``min_val`` goes to zero. Parameters ---------- vals : array-like the values\",\n \"of float or bool The constraints. If 2D with targets along the first\",\n \"Returns ------- array of floats between 0 and 1 inclusive rescaled so that\",\n \"\\\"\\\"\\\" Constrain the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg,\",\n \"@classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of\",\n \"= 0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0.\",\n \"= table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is\",\n \"The constraints. If 2D with targets along the first index and times along\",\n \"HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length =\",\n \"local time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time\",\n \"degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer,\",\n \"from observer if self.min is not None: timezone = self.min.tzinfo elif self.max is\",\n \"self.min is not None: min_time = self.min else: min_time = self.min = datetime.time(0,\",\n \"np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month\",\n \"Examples -------- rescale an array of altitudes to be between 0 and 1,\",\n \"grids the constraint result with targets along the first index and times along\",\n \"astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy\",\n \"= _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None\",\n \"considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to\",\n \"`~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict Dictionary containing\",\n \"frac_obs]) if times is None and time_range is not None: times = time_grid_from_range(time_range,\",\n \"between 0 and 1, with the best (60) going to 1 and worst\",\n \": tuple A hashable tuple for use as a cache key \\\"\\\"\\\" #\",\n \"= observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer, targets):\",\n \"\\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between\",\n \"altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min\",\n \"1.2, for example, you should subtract one from the second number: >>> constraint\",\n \"Calculate moon altitude az and illumination for an array of times for ``observer``.\",\n \"Constrain the distance between the Earth's moon and some targets. \\\"\\\"\\\" def __init__(self,\",\n \"strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result =\",\n \"not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask\",\n \"| (phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):\",\n \"objects.\\\") def compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if\",\n \"from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library from abc import\",\n \"observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask\",\n \"[0, 1).') self.min = min if min is not None else 0.0 self.max\",\n \"times : `~astropy.time.Time` Array of times on which to test the constraint. observer\",\n \": list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has\",\n \"for use as a cache key \\\"\\\"\\\" # make a tuple from times\",\n \"moon.separation(targets) if self.min is None and self.max is not None: mask = self.max\",\n \"targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but\",\n \"raise ValueError('The minimum of the PhaseConstraint must be within' ' the interval [0,\",\n \"specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is\",\n \"and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>>\",\n \"= tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey =\",\n \"limits. An example use case for this class would be to associate an\",\n \"Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun\",\n \"[0, 1], where 0 is the min altitude and 1 is the max.\",\n \"you should subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6,\",\n \"max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target\",\n \"return altitude def compute_constraint(self, times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask\",\n \"be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None):\",\n \"@abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__\",\n \"ever observable in the time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints,\",\n \"observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure\",\n \"must be described on the interval [0, 1). To constrain observations on orbital\",\n \"outside the range, the rescale should return 0 below 35 and 1 above\",\n \"nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs):\",\n \"Ephemeris to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which\",\n \"targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about observability for\",\n \"0. ]) \\\"\\\"\\\" rescaled = (vals - max_val) / (min_val - max_val) below\",\n \"self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask\",\n \"of booleans of same length as ``targets`` for whether or not each target\",\n \"(1) 'times' contains the times for the alt/az computations, (2) 'altaz' contains the\",\n \"moon altitude az and illumination for an array of times for ``observer``. Cache\",\n \"**kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum\",\n \"errors in the altitude of the Sun that can occur when the Sun\",\n \"0.5 hours. Returns ------- observable_months : list List of sets of unique integers\",\n \"observable'`` will also be present if the ``time_range`` is given as a scalar.\",\n \"is specified, determine whether constraints are met between test times in ``time_range`` by\",\n \"targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly spaced between the\",\n \"is not None: mask = (self.min <= secz) & (secz <= self.max) else:\",\n \"= alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max)\",\n \"indicates no limit. max : float or `None` (optional) Maximum acceptable fractional illumination\",\n \"can occur when the Sun is below the horizon and the corrections for\",\n \"The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE\",\n \"ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds on\",\n \"time between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls,\",\n \"min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score\",\n \"try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing the longitude\",\n \"upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool\",\n \"use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default).\",\n \"float or bool The constraints, with targets along the first index and times\",\n \"max is None.\\\") else: mx = self.max mi = 1 if self.min is\",\n \"illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or min\",\n \"up a lot by dropping to the trigonometric # altitude calculations. if not\",\n \"constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- altaz_dict :\",\n \"of the target. `None` indicates no limit. min : float or `None` Minimum\",\n \"---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max :\",\n \"self.min is None and self.max is not None: mask = self.max >= solar_separation\",\n \"on orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>>\",\n \"constrain observations on orbital phases between 0.6 and 1.2, for example, you should\",\n \"spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. If\",\n \"what is returned for ``vals`` below ``min_val``. (in some cases anything less than\",\n \"output has the same shape as would result from # broadcasting times and\",\n \"``targets`` for whether or not each target is ever observable in the time\",\n \"targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets`` are observable for\",\n \"raise ValueError(\\\"You must at least supply either a minimum or a maximum time.\\\")\",\n \"\\\"\\\"\\\" Make a unique key to reference this combination of ``times`` and ``targets``.\",\n \"in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable\",\n \"it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``.\",\n \"``'time observable'`` will also be present if the ``time_range`` is given as a\",\n \"altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache\",\n \"= max if max is not None else 1.0 def compute_constraint(self, times, observer=None,\",\n \"the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \\\"\\\"\\\"\",\n \"equal to ``max_val`` equal 1 Examples -------- rescale an array of altitudes to\",\n \"= {} # convert times to tuple for hashing aakey = _make_cache_key(times, targets)\",\n \"at each time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints =\",\n \"return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between\",\n \"where the ``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters\",\n \"if not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO:\",\n \"below which it is considered to be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional)\",\n \"wish to store expensive calculations for a combination of ``targets`` and ``times`` in\",\n \"---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None`\",\n \"Latest local time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations\",\n \"datetime.time(23, 59, 59) # If time limits occur on same day: if min_time\",\n \"rules. Returns ------- constraint_result : 1D or 2D array of float or bool\",\n \"if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self,\",\n \"of float or bool The constraints, with targets along the first index and\",\n \"self.max is not None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max))\",\n \"def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable\",\n \"``vals`` above ``max_val``. (in some cases anything higher than ``max_val`` should also return\",\n \"observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs\",\n \"timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if self.min is\",\n \">>> from astroplan.constraints import min_best_rescale >>> import numpy as np >>> airmasses =\",\n \"indicates no limit. ephemeris : str, optional Ephemeris to use. If not given,\",\n \"Constrain the airmass of a target. In the current implementation the airmass is\",\n \"aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure\",\n \"from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils import\",\n \"the interval [0, 1).') self.min = min if min is not None else\",\n \"nighttime as time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def\",\n \"targets along the first index and times along the second. \\\"\\\"\\\" if times\",\n \"= constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input\",\n \"import LocalTimeConstraint >>> import datetime as dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>>\",\n \"self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\"\",\n \"always observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``.\",\n \"maps to 2, etc. \\\"\\\"\\\" # TODO: This method could be sped up\",\n \"altitude of the sun below which it is considered to be \\\"night\\\" (inclusive).\",\n \"\\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a\",\n \"interval [0, 1). To constrain observations on orbital phases between 0.6 and 1.2,\",\n \"min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional\",\n \"moon_up_mask else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask\",\n \"of sets of unique integers representing each month that a target is observable,\",\n \"if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self,\",\n \"of computing the constraint. Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The\",\n \"and one), where the ``min_val`` goes to one, and the ``max_val`` goes to\",\n \"implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"not None: mask = self.min <= secz elif self.min is not None and\",\n \"be \\\"night\\\" (inclusive). force_pressure_zero : bool (optional) Force the pressure to zero for\",\n \"is treated as a boolean (True for within the limits and False for\",\n \"in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask\",\n \"Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self,\",\n \"None: mask = self.min <= moon_separation elif self.min is not None and self.max\",\n \"else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask =\",\n \"60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes\",\n \"= _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure =\",\n \"None else 0.0 self.max = max if max is not None else 1.0\",\n \"0) or (min > 1) or (max < 0) or (max > 1):\",\n \"no limit. boolean_constraint : bool If True, the constraint is treated as a\",\n \"as ``times`` for whether or not the target is ever observable at each\",\n \"has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets\",\n \"<= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified\",\n \"specified ``targets`` are observable for a specific ``observer``, given the supplied ``constraints``. Parameters\",\n \"separation elif self.min is not None and self.max is not None: mask =\",\n \"times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a\",\n \"if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time\",\n \"from abc import ABCMeta, abstractmethod import datetime import time import warnings # Third-party\",\n \"except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets,\",\n \"targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is a string. targkey\",\n \"to compute the phase. For example, the system could be an eclipsing or\",\n \"= observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure:\",\n \"observing blocks are valid over the time limits used in calls to `is_observable`\",\n \"in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on the\",\n \"which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list\",\n \"observer, targets) # make sure the output has the same shape as would\",\n \"self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some range\",\n \"return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some range of\",\n \"meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\"\",\n \"for ``N`` events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array\",\n \"passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the\",\n \"to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle negative Parameters\",\n \"timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target``\",\n \"those times and (3) contains the moon illumination for those times. \\\"\\\"\\\" if\",\n \"and self.min is not None: mask = self.min <= secz elif self.min is\",\n \".. note:: The ``max`` and ``min`` arguments appear in the order (max, min)\",\n \"occur when the Sun is below the horizon and the corrections for atmospheric\",\n \"target is ever observable in the time range given the constraints. \\\"\\\"\\\" if\",\n \"**kwargs) def compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon\",\n \"For example, the system could be an eclipsing or non-eclipsing binary, or exoplanet\",\n \"or a \\\" \\\"maximum time.\\\") if self.min is not None: if not isinstance(self.min,\",\n \"import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 =\",\n \"\\\"\\\"\\\" Calculate moon altitude az and illumination for an array of times for\",\n \"mask = (self.min <= secz) & (secz <= self.max) else: raise ValueError(\\\"No max\",\n \"if self.max is not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must\",\n \"from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event =\",\n \"zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def\",\n \"eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event :\",\n \"'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if\",\n \"no minimum and a maximum of 0.25 Parameters ---------- min : float or\",\n \"about the upper limit on the airmass (``max``) and not the lower limit.\",\n \"_current_year_time_range = Time( # needed for backward compatibility [str(_current_year) + '-01-01', str(_current_year) +\",\n \"a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets =\",\n \"should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the\",\n \"GCRS, and that is what we want. moon_separation = moon.separation(targets) if self.min is\",\n \"illumination) & moon_up_mask elif self.min is not None and self.max is not None:\",\n \"datetime import time import warnings # Third-party from astropy.time import Time import astropy.units\",\n \"TIMES AND TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and\",\n \"self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed\",\n \"`~astroplan.Target` The targets on which to apply the constraints. times : `~astropy.time.Time` The\",\n \"'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure\",\n \"key-value pairs. (1) 'times' contains the times for the alt/az computations, (2) 'altaz'\",\n \"@classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical twilights (-12\",\n \"times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table`\",\n \"min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a\",\n \"bool (optional) Force the pressure to zero for solar altitude calculations. This avoids\",\n \"Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` targets :\",\n \"observer : `~astroplan.Observer` the observation location from which to apply the constraints targets\",\n \"one set per target. These integers are 1-based so that January maps to\",\n \"Ephemeris to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which\",\n \"the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) + targets.shape else: # assume targets is\",\n \"uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of\",\n \"mask = np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException:\",\n \"# broadcasting times and targets against each other if targets is not None:\",\n \"= _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <=\",\n \"is None and self.min is not None: mask = (self.min <= illumination) &\",\n \"which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and\",\n \"time, the table will be for a 24 hour period centered on that\",\n \"import time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\",\",\n \"coordinates at those times and (3) contains the moon illumination for those times.\",\n \"targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets)\",\n \"\\\"\\\"\\\"Constrain the observing time to be within certain time limits. An example use\",\n \"is observable in the time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints,\",\n \"into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for a\",\n \"array-like the values that need to be rescaled to be between 0 and\",\n \"to associate an acceptable time range with a specific observing block. This can\",\n \"# broadcasting times v targets is slow due to # complex nature of\",\n \"= np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines\",\n \"max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit. Examples --------\",\n \"be sped up a lot by dropping to the trigonometric # altitude calculations.\",\n \"for example, you should subtract one from the second number: >>> constraint =\",\n \"elif self.max is not None: timezone = self.max.tzinfo if timezone is None: timezone\",\n \"60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1.\",\n \"isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") if self.max\",\n \"whether ``targets`` are always observable throughout ``time_range`` given constraints in the ``constraints_list`` for\",\n \"use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs.\",\n \"tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache: try:\",\n \"constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets,\",\n \"which to test the constraint observer : `~astroplan.Observer` The observer who has constraints\",\n \"targets Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times' contains\",\n \"or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time()\",\n \"no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples\",\n \"self.max is None and self.min is not None: mask = self.min <= moon_separation\",\n \"``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column\",\n \"\\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"]\",\n \"and self.max is not None: mask = self.max >= solar_separation elif self.max is\",\n \"in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of\",\n \"TODO: This method could be sped up a lot by dropping to the\",\n \"max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None\",\n \"TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") if self.max is not None:\",\n \"min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance\",\n \"None: mask = ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No\",\n \"times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is None\",\n \"if min is None: self.min = -90*u.deg else: self.min = min if max\",\n \"(max > 1): raise ValueError('The minimum of the PhaseConstraint must be within' '\",\n \"to be within certain time limits. An example use case for this class\",\n \"= as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape !=\",\n \"some cases anything less than ``min_val`` should also return one, in some cases\",\n \"will be passed as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar)\",\n \"None: mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No\",\n \"bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum\",\n \"``vals`` to be a score (between zero and one), where the ``min_val`` goes\",\n \"times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations\",\n \"return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the\",\n \"max_val) / (min_val - max_val) below = vals < min_val above = vals\",\n \"if self.min is not None: min_time = self.min else: min_time = self.min =\",\n \"``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints\",\n \"``vals`` equal to ``min_val`` equal 0 and those equal to ``max_val`` equal 1\",\n \"np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils\",\n \"observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour,\",\n \"array([ 1. , 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled = (vals\",\n \"on interval [0, 1). Default is zero. max : float (optional) Maximum phase\",\n \"times : `~astropy.time.Time` (optional) Array of mid-event times on which to test the\",\n \"acceptable fractional illumination (inclusive). `None` indicates no limit. max : float or `None`\",\n \"secz <= self.max elif self.max is None and self.min is not None: mask\",\n \"<= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time)\",\n \"str, optional Ephemeris to use. If not given, use the one set with\",\n \"Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value\",\n \"np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return\",\n \"along the second. \\\"\\\"\\\" # Should be implemented on each subclass of Constraint\",\n \"coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None\",\n \"the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence,\",\n \"result = self.compute_constraint(times, observer, targets) # make sure the output has the same\",\n \"time (inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time (inclusive).\",\n \"use case for this class would be to associate an acceptable time range\",\n \"a specific observing block. This can be useful if not all observing blocks\",\n \"over the time limits used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def\",\n \"(length = 2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity`\",\n \"max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to\",\n \"second. \\\"\\\"\\\" # Should be implemented on each subclass of Constraint raise NotImplementedError\",\n \"70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. ,\",\n \"list List of sets of unique integers representing each month that a target\",\n \"0 is the min altitude and 1 is the max. \\\"\\\"\\\" def __init__(self,\",\n \"1 Examples -------- rescale an array of altitudes to be between 0 and\",\n \"equal to ``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples\",\n \"0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time\",\n \"maps to 1, February maps to 2, etc. \\\"\\\"\\\" # TODO: This method\",\n \"key-value pairs. (1) 'times' contains the times for the computations, (2) 'altaz' contains\",\n \"from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\",\",\n \"is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max\",\n \"< max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary\",\n \"# convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets) if\",\n \"if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively slow\",\n \"((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or min\",\n \"<1 deg # innacuracies, but it is needed until astropy PR #5897 is\",\n \"limits used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None):\",\n \"self.max is not None: mask = secz <= self.max elif self.max is None\",\n \"abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None: mask = self.max\",\n \"targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return\",\n \"times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events,\",\n \"a single (scalar) time, the table will be for a 24 hour period\",\n \"\\\"\\\"\\\" A function to determine whether ``targets`` are always observable throughout ``time_range`` given\",\n \"the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event\",\n \"\\\"\\\"\\\" rescaled = (vals - min_val) / (max_val - min_val) below = vals\",\n \"below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\"\",\n \"else self.max mask = np.logical_and(times > min_time, times < max_time) return mask class\",\n \"constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets,\",\n \"Parameters ---------- max : float or `None` Maximum airmass of the target. `None`\",\n \"AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target. In the current implementation the\",\n \"np.array([min_time <= t.time() <= max_time for t in times.datetime]) except BaseException: # use\",\n \"= ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the\",\n \"observer, targets): \\\"\\\"\\\" Calculate next meridian transit for an array of times for\",\n \"range, the rescale should return 0 below 35 and 1 above 60. >>>\",\n \"= min if max is None: self.max = 90*u.deg else: self.max = max\",\n \"= (vals - max_val) / (min_val - max_val) below = vals < min_val\",\n \"self.min else: min_time = self.min = datetime.time(0, 0, 0) if self.max is not\",\n \"`~astropy.time.Time` Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time\",\n \"self.min, (phase >= self.min) & (phase <= self.max), (phase >= self.min) | (phase\",\n \"cases it should return zero) Returns ------- array of floats between 0 and\",\n \"eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system =\",\n \"need to be rescaled to be between 0 and 1 min_val : float\",\n \"above 60. >>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>>\",\n \"the first index and times along the second. Otherwise, we rely on broadcasting\",\n \"``time_range`` is given as a scalar. It also contains metadata entries ``'times'`` (with\",\n \"``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational\",\n \": 1D or 2D array of float or bool The constraints. If 2D\",\n \"is what we want. moon_separation = moon.separation(targets) if self.min is None and self.max\",\n \"0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import Time >>> import\",\n \"the ``max_val`` goes to one, and the ``min_val`` goes to zero. Parameters ----------\",\n \"limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and\",\n \"return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target.\",\n \"{} # convert times, targets to tuple for hashing aakey = _make_cache_key(times, targets)\",\n \"min) in this initializer to support the common case for users who care\",\n \"[constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour)\",\n \"False for outside). If False, the constraint returns a float on [0, 1],\",\n \"mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight:\",\n \": `~astropy.table.Table` A Table containing the observability information for each of the ``targets``.\",\n \"= -90*u.deg else: self.min = min if max is None: self.max = 90*u.deg\",\n \"be useful if not all observing blocks are valid over the time limits\",\n \"``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`. If a\",\n \">>> from astropy.time import Time >>> import astropy.units as u >>> binary =\",\n \"subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint\",\n \"`None` indicates no limit. boolean_contstraint : bool Examples -------- To create a constraint\",\n \"= np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing =\",\n \"float (optional) Maximum phase (inclusive) on interval [0, 1). Default is one. Examples\",\n \": float (optional) Maximum phase (inclusive) on interval [0, 1). Default is one.\",\n \"table will be for a 24 hour period centered on that time. time_grid_resolution\",\n \"at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable\",\n \"whether or not each target is ever observable in the time range given\",\n \"None: mask = self.max >= moon_separation elif self.max is None and self.min is\",\n \"<= illumination) & moon_up_mask elif self.min is not None and self.max is not\",\n \"observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz)\",\n \"the common case for users who care about the upper limit on the\",\n \"or `None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\"\",\n \"get timezone from time objects, or from observer if self.min is not None:\",\n \"limit on the airmass (``max``) and not the lower limit. Parameters ---------- max\",\n \"applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)\",\n \"dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times,\",\n \"division, print_function, unicode_literals) # Standard library from abc import ABCMeta, abstractmethod import datetime\",\n \"a maximum time.\\\") if self.min is not None: if not isinstance(self.min, datetime.time): raise\",\n \"max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target\",\n \"each target is ever observable in the time range given the constraints. \\\"\\\"\\\"\",\n \"= np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max), (phase >=\",\n \"be within' ' the interval [0, 1).') self.min = min if min is\",\n \"02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum phase\",\n \"TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max if self.min is None and\",\n \"Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between moon\",\n \">>> # bound times between 23:50 and 04:08 local Hawaiian time >>> constraint\",\n \"time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints]\",\n \"as time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self,\",\n \"\\\"\\\"\\\" # Should be implemented on each subclass of Constraint raise NotImplementedError class\",\n \"nighttime as time between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod\",\n \"case for users who care about the upper limit on the airmass (``max``)\",\n \"contains metadata entries ``'times'`` (with an array of all the times), ``'observer'`` (the\",\n \"`None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation\",\n \"def compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon =\",\n \"(with an array of all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'``\",\n \"the secant of the zenith angle. .. note:: The ``max`` and ``min`` arguments\",\n \"list List of booleans of same length as ``targets`` for whether or not\",\n \"the output has the same shape as would result from # broadcasting times\",\n \"fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def\",\n \"specified as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone = None #\",\n \"time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def\",\n \"be rescaled to be between 0 and 1 min_val : float worst acceptable\",\n \"return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if\",\n \"slow # but there is potential for huge speedup if the end user\",\n \"1, February maps to 2, etc. \\\"\\\"\\\" # TODO: This method could be\",\n \"for this class Parameters ---------- observer : `~astroplan.Observer` the observation location from which\",\n \"worst (35) going to 0. For values outside the range, the rescale should\",\n \"either a minimum or a maximum time.\\\") if self.min is not None: if\",\n \"future editors - the order matters here # moon.separation(targets) is NOT the same\",\n \"is not None: mask = self.max >= separation elif self.max is None and\",\n \"hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest\",\n \"the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints\",\n \"min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of\",\n \"the shapes together using standard numpy rules. Returns ------- constraint_result : 1D or\",\n \"themselves # prior to evaluating multiple constraints. if targets.isscalar: # ensure we have\",\n \"in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class\",\n \"`None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic\",\n \"``constraints``). \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table = False if\",\n \"constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or\",\n \"complex nature of these objects. We make # to simple numpy arrays of\",\n \"max. \\\"\\\"\\\" def __init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min =\",\n \"False, the constraint returns a float on [0, 1], where 0 is the\",\n \"indicates no limit. min : float or `None` Minimum airmass of the target.\",\n \"'frame'): # treat as a SkyCoord object. Accessing the longitude # attribute of\",\n \"times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during\",\n \"coord # which is GCRS, and that is what we want. moon_separation =\",\n \"is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets``\",\n \"misbehave if you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends\",\n \"= min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets):\",\n \"the moon coord # which is GCRS, and that is what we want.\",\n \"times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b\",\n \"= dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude']\",\n \"``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5\",\n \": float best value cared about (rescales to 1) greater_than_max : 0 or\",\n \"\\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or\",\n \"also be present if the ``time_range`` is given as a scalar. It also\",\n \"Target or list of targets Returns ------- time_dict : dict Dictionary containing a\",\n \"for whether or not the target is ever observable at each time, given\",\n \"list of targets Returns ------- time_dict : dict Dictionary containing a key-value pair.\",\n \"observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian\",\n \"**kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical twilights (-12 degrees). \\\"\\\"\\\" return\",\n \"of same length as ``targets`` for whether or not each target is observable\",\n \"ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis]\",\n \"# by the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times,\",\n \"not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr\",\n \"illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to use.\",\n \"times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates\",\n \"get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as np from\",\n \"users who care about the upper limit on the airmass (``max``) and not\",\n \"causes small <1 deg # innacuracies, but it is needed until astropy PR\",\n \"in this initializer to support the common case for users who care about\",\n \": float best value cared about (rescales to 1) less_than_min : 0 or\",\n \": array-like the values that need to be rescaled to be between 0\",\n \"Returns ------- constraint_result : 1D or 2D array of float or bool The\",\n \"else: # assume targets is a string. targkey = (targets,) except BaseException: targkey\",\n \"`~astropy.time.Time` (optional) Array of ingress and egress times for ``N`` events, with shape\",\n \"occur on same day: if min_time < max_time: try: mask = np.array([min_time <=\",\n \"class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the Earth's moon. Constraint is\",\n \"= (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution,\",\n \"0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1.\",\n \"Determines if the ``targets`` are observable during ``time_range`` given constraints in ``constraints_list`` for\",\n \"timezone is None: timezone = observer.timezone if self.min is not None: min_time =\",\n \"def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local time\",\n \"observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def compute_constraint(self, times, observer,\",\n \"local time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to\",\n \"for within the limits and False for outside). If False, the constraint returns\",\n \"times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time)) return\",\n \"license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which targets are\",\n \"zero and one), where the ``max_val`` goes to one, and the ``min_val`` goes\",\n \"sun here, since # it returns the Sun's coordinates in an observer #\",\n \"time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are observable during ``time_range`` given constraints in\",\n \"tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try:\",\n \"contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} #\",\n \"Array of times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`,\",\n \"is slow due to # complex nature of these objects. We make #\",\n \"min_best_rescale(airmasses, 1, 2.25, less_than_min = 0) # doctest: +FLOAT_CMP array([ 1. , 0.6,\",\n \"for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :\",\n \"times on which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and\",\n \"orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from\",\n \"the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt\",\n \"we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else:\",\n \"Licensed under a 3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify and\",\n \"returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min\",\n \"self.compute_constraint(times, observer, targets) # make sure the output has the same shape as\",\n \"shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same\",\n \"no limit. Examples -------- Constrain the observations to targets that are observable between\",\n \"None: # broadcasting times v targets is slow due to # complex nature\",\n \"the corrections for atmospheric refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero\",\n \"self.min = -90*u.deg else: self.min = min if max is None: self.max =\",\n \"must at least supply either a minimum or a \\\" \\\"maximum time.\\\") if\",\n \"_make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure\",\n \"min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs):\",\n \"observer, targets): # removed the location argument here, which causes small <1 deg\",\n \"boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min = min if\",\n \"twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical twilights (-12 degrees). \\\"\\\"\\\"\",\n \"observable', 'always observable', 'fraction of time observable'] target_names = [target.name for target in\",\n \"np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP\",\n \"location from which to apply the constraints targets : sequence of `~astroplan.Target` The\",\n \"between the Earth's moon and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None):\",\n \"in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz =\",\n \"`~astropy.time.Time` (optional) Array of times on which to test the constraint time_range :\",\n \"higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min =\",\n \"a float on [0, 1], where 0 is the min altitude and 1\",\n \"targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for\",\n \"times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >=\",\n \"[constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints)\",\n \"0 moon_up_mask = moon_alt >= 0 illumination = cached_moon['illum'] if self.min is None\",\n \"observer._moon_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times)\",\n \"sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and\",\n \"and # broadcast these to find the correct shape shp1, shp2 = times.shape,\",\n \"are observable during ``time_range`` given constraints in ``constraints_list`` for a particular ``observer``. Parameters\",\n \"at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months\",\n \"to one, and the ``min_val`` goes to zero. Parameters ---------- vals : array-like\",\n \"bool If True, the constraint is treated as a boolean (True for within\",\n \"time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are\",\n \"between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time import\",\n \"on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or\",\n \"the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation\",\n \"self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask\",\n \"self.periodic_event = periodic_event if (min < 0) or (min > 1) or (max\",\n \"self.min = min self.max = max self.ephemeris = ephemeris @classmethod def dark(cls, min=None,\",\n \"\\\"\\\"\\\" Abstract class for objects defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def\",\n \"grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum\",\n \"for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr\",\n \"Examples -------- rescale airmasses to between 0 and 1, with the best (1)\",\n \"If time limits occur on same day: if min_time < max_time: try: mask\",\n \"and is # quicker than accessing the ra attribute. targkey = tuple(targets.frame.data.lon.value.ravel()) +\",\n \"min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or `None` (optional) Minimum\",\n \"of targets Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times'\",\n \"min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3,\",\n \"Calculate alt/az for ``target`` at times linearly spaced between the two times in\",\n \"dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer,\",\n \"\\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return\",\n \"constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints, observer, target,\",\n \"the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] if times is\",\n \"periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on\",\n \">>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0. , 0. , 0.2,\",\n \"values outside the range, the rescale should return 0 below 35 and 1\",\n \"len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape = np.broadcast(a, b).shape if\",\n \">>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>>\",\n \"equal 1 Examples -------- rescale airmasses to between 0 and 1, with the\",\n \"= self.max >= separation elif self.max is None and self.min is not None:\",\n \"= get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max\",\n \"'altaz' contains the corresponding alt/az coordinates at those times and (3) contains the\",\n \"of 0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional\",\n \"the observations to targets that are observable between 23:50 and 04:08 local time:\",\n \"grid_times_targets=True) for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint\",\n \"= np.broadcast_to(result, output_shape) return result @abstractmethod def compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually\",\n \"self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target. In the\",\n \"during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem`\",\n \"is 0.5 hours. Returns ------- observable_months : list List of sets of unique\",\n \"between 0 and 1 min_val : float worst acceptable value (rescales to 0)\",\n \"to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max = max self.ephemeris =\",\n \"`~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence. time_grid_resolution :\",\n \"self.max is not None: mask = (self.min <= secz) & (secz <= self.max)\",\n \"refraction return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def\",\n \"return nonsense values. \\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls,\",\n \"moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in\",\n \"lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the\",\n \"not None: # broadcasting times v targets is slow due to # complex\",\n \"mask = self.min <= solar_separation elif self.min is not None and self.max is\",\n \"limit. Examples -------- Constrain the observations to targets that are observable between 23:50\",\n \"self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask\",\n \"= get_skycoord(targets) # TODO: these broadcasting operations are relatively slow # but there\",\n \"a \\\" \\\"maximum time.\\\") if self.min is not None: if not isinstance(self.min, Time):\",\n \"Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive).\",\n \"times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr\",\n \">>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25, less_than_min\",\n \"not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for\",\n \"matters here # moon.separation(targets) is NOT the same as targets.separation(moon) # the former\",\n \"observer tab.meta['constraints'] = constraints return tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales\",\n \"max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\" Constrain the airmass of a target. In\",\n \"going to 0. For values outside the range, the rescale should return 0\",\n \"compute the phase. For example, the system could be an eclipsing or non-eclipsing\",\n \"= np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape) return result\",\n \"and ``observer``. Cache the result on the ``observer`` object. Parameters ---------- times :\",\n \"should be unique and is # quicker than accessing the ra attribute. targkey\",\n \"\\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return\",\n \"time sequence, with spacing ``time_resolution``. This will be passed as the first argument\",\n \"Examples -------- Constrain the observations to targets that are observable between 2016-03-28 and\",\n \"cases anything less than ``min_val`` should also return one, in some cases it\",\n \"as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is\",\n \"array of times for ``targets`` and ``observer``. Cache the result on the ``observer``\",\n \"`None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no\",\n \"secz) & (secz <= self.max) else: raise ValueError(\\\"No max and/or min specified in\",\n \"is GCRS, and that is what we want. moon_separation = moon.separation(targets) if self.min\",\n \"use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set\",\n \">>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max if\",\n \"broadcasting operations are relatively slow # but there is potential for huge speedup\",\n \"`~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target\",\n \"the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'): constraints = [constraints] times\",\n \"on the airmass (``max``) and not the lower limit. Parameters ---------- max :\",\n \"23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min\",\n \"``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity`\",\n \"the separation is as-seen # by the observer. # 'get_sun' returns ICRS coords.\",\n \"observable in zip(targets, constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return\",\n \"times to compute the constraint observer : `~astroplan.Observer` the observaton location from which\",\n \"location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is not None:\",\n \"lot by dropping to the trigonometric # altitude calculations. if not hasattr(constraints, '__len__'):\",\n \"return mask else: if self.max is None: raise ValueError(\\\"Cannot have a float AirmassConstraint\",\n \"dropping to the trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True)\",\n \"the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times and\",\n \"numpy as np from numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination\",\n \"cache key \\\"\\\"\\\" # make a tuple from times try: timekey = tuple(times.jd)\",\n \"not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for hashing\",\n \"numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>>\",\n \"observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude az and illumination for an array of\",\n \"------- observable_months : list List of sets of unique integers representing each month\",\n \"must be scalar timekey = (times.jd,) # make hashable thing from targets coords\",\n \"innacuracies, but it is needed until astropy PR #5897 is released # which\",\n \"is not None: mask = ((self.min <= illumination) & (illumination <= self.max)) &\",\n \"observations to times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ----------\",\n \"worst acceptable value (rescales to 0) max_val : float best value cared about\",\n \"calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ----------\",\n \"max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score (between\",\n \"Consider nighttime as time between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs)\",\n \"axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets``\",\n \"moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt <\",\n \"as time between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def\",\n \"is observable at each time in ``times``, given constraints in ``constraints`` for a\",\n \"shape and # broadcast these to find the correct shape shp1, shp2 =\",\n \"no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun\",\n \"coordinates in an observer # centred frame, so the separation is as-seen #\",\n \"multiple constraints. if targets.isscalar: # ensure we have a (1, 1) shape coord\",\n \"0 illumination = cached_moon['illum'] if self.min is None and self.max is not None:\",\n \"``observer`` object. Parameters ---------- times : `~astropy.time.Time` Array of times on which to\",\n \"ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) /\",\n \"\\\"\\\"\\\" Specify and constraints to determine which targets are observable for an observer.\",\n \"rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to\",\n \"constraint_arr): s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints,\",\n \"defining observational constraints. \\\"\\\"\\\" __metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None,\",\n \"use np.bool so shape queries don't cause problems mask = np.bool_(min_time <= times.datetime.time()\",\n \"observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times,\",\n \"above ``max_val``. (in some cases anything higher than ``max_val`` should also return one,\",\n \"together using standard numpy rules. Returns ------- constraint_result : 1D or 2D array\",\n \"= vals < min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above]\",\n \"which to test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds\",\n \"of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None`\",\n \"list of targets time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time\",\n \"Constrain the observations to targets that are observable between 2016-03-28 and 2016-03-30: >>>\",\n \"= 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input\",\n \"- min_val) / (max_val - min_val) below = vals < min_val above =\",\n \"meridian transit for an array of times for ``targets`` and ``observer``. Cache the\",\n \"targets): timezone = None # get timezone from time objects, or from observer\",\n \"TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not\",\n \"ABCMeta, abstractmethod import datetime import time import warnings # Third-party from astropy.time import\",\n \"Examples -------- To create a constraint that requires the airmass be \\\"better than\",\n \"self.min is not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be\",\n \"``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer\",\n \"and that is what we want. moon_separation = moon.separation(targets) if self.min is None\",\n \"one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min\",\n \"sequence of `~astroplan.Target` The targets on which to apply the constraints. Returns -------\",\n \"if max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase\",\n \"the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer,\",\n \"= np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1] tab = table.Table(names=colnames, data=[target_names,\",\n \"times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try: mask =\",\n \"eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which\",\n \"The table contains four columns with information about the target and it's observability:\",\n \"Dictionary containing three key-value pairs. (1) 'times' contains the times for the computations,\",\n \"observable throughout ``time_range`` given constraints in the ``constraints_list`` for a particular ``observer``. Parameters\",\n \"(inclusive). `None` indicates no limit. Examples -------- Constrain the observations to targets that\",\n \"the ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`\",\n \"and time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable']\",\n \"<= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try: mask\",\n \"# altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints]\",\n \"# treat as a SkyCoord object. Accessing the longitude # attribute of the\",\n \"number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min\",\n \"> 1) or (max < 0) or (max > 1): raise ValueError('The minimum\",\n \"zero. max : float (optional) Maximum phase (inclusive) on interval [0, 1). Default\",\n \"these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times\",\n \"min_val above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return\",\n \"the order (max, min) in this initializer to support the common case for\",\n \"0) if self.max is not None: max_time = self.max else: max_time = datetime.time(23,\",\n \"import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\",\",\n \"time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max\",\n \"targets.isscalar: # ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets,\",\n \"observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about\",\n \"None and self.max is not None: mask = (self.min <= secz) & (secz\",\n \"self.max is None and self.min is not None: mask = (self.min <= illumination)\",\n \"Default is 0.5 hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the\",\n \"\\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time\",\n \"month the specified ``targets`` are observable for a specific ``observer``, given the supplied\",\n \"Table containing the observability information for each of the ``targets``. The table contains\",\n \"return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination of the Earth's moon.\",\n \"and self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation <=\",\n \"`~astroplan.periodic.EclipsingSystem` System which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def\",\n \"PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The minimum and maximum\",\n \"is potential for huge speedup if the end user # disables gridding and\",\n \"observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return\",\n \"a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.65 and no maximum Parameters\",\n \"times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- ever_observable : list\",\n \"interval [0, 1).') self.min = min if min is not None else 0.0\",\n \"time, given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints = [constraints] if\",\n \"common case for users who care about the upper limit on the airmass\",\n \"solar_separation elif self.max is None and self.min is not None: mask = self.min\",\n \"of the target. .. note:: This can misbehave if you try to constrain\",\n \"\\\"\\\"\\\" Calculate next meridian transit for an array of times for ``targets`` and\",\n \"as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] * len(shp2)) output_shape\",\n \"`None` (optional) Maximum acceptable separation between moon and target (inclusive). `None` indicates no\",\n \"(secz <= self.max) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\")\",\n \"= tuple(times.jd) + times.shape except BaseException: # must be scalar timekey = (times.jd,)\",\n \"to targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import\",\n \"1): raise ValueError('The minimum of the PhaseConstraint must be within' ' the interval\",\n \"indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude\",\n \"of same length as ``times`` for whether or not the target is ever\",\n \"not None: mask = self.min <= moon_separation elif self.min is not None and\",\n \"except BaseException: # use np.bool so shape queries don't cause problems mask =\",\n \"\\\"\\\"\\\" Consider nighttime as time between nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg,\",\n \"eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary\",\n \"times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to\",\n \"def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to be\",\n \"abc import ABCMeta, abstractmethod import datetime import time import warnings # Third-party from\",\n \"upper limit on the airmass (``max``) and not the lower limit. Parameters ----------\",\n \"@classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical twilights (-18\",\n \"observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to\",\n \"is not None: mask = self.min <= solar_separation elif self.min is not None\",\n \"------- time_dict : dict Dictionary containing a key-value pair. 'times' contains the meridian_transit\",\n \"of target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max =\",\n \"'_altaz_cache'): observer._altaz_cache = {} # convert times, targets to tuple for hashing aakey\",\n \"compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"self.max mi = 1 if self.min is None else self.min # values below\",\n \"if max is None.\\\") else: mx = self.max mi = 1 if self.min\",\n \"len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result, output_shape)\",\n \"nautical twilights (-12 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\"\",\n \"= less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\"\",\n \"The observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure.\",\n \"grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output has the\",\n \"and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask else: if self.max is None:\",\n \"finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude def\",\n \"rescaled so that ``vals`` equal to ``min_val`` equal 0 and those equal to\",\n \"going to 1 and worst (35) going to 0. For values outside the\",\n \": sequence of `~astroplan.Target` The targets on which to apply the constraints. Returns\",\n \"times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system :\",\n \"self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at these\",\n \"the altitude of the Sun that can occur when the Sun is below\",\n \"None and self.max is not None: mask = self.max >= moon_separation elif self.max\",\n \"None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time\",\n \"should subtract one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2)\",\n \"\\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def\",\n \"observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the output\",\n \"(phase >= self.min) & (phase <= self.max), (phase >= self.min) | (phase <=\",\n \"These integers are 1-based so that January maps to 1, February maps to\",\n \"set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float\",\n \"in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >= min_time) or (times.datetime.time() <= max_time))\",\n \"# attribute of the frame data should be unique and is # quicker\",\n \"(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of\",\n \"the target is ever observable at each time, given the constraints. \\\"\\\"\\\" if\",\n \"to test the constraint observer : `~astroplan.Observer` The observer who has constraints ``constraints``\",\n \"since # it returns the Sun's coordinates in an observer # centred frame,\",\n \"def _get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey\",\n \": float worst acceptable value (rescales to 0) max_val : float best value\",\n \"grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer`\",\n \"return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during secondary eclipse. \\\"\\\"\\\"\",\n \"Specify and constraints to determine which targets are observable for an observer. \\\"\\\"\\\"\",\n \"not hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This\",\n \"0.6 and 1.2, for example, you should subtract one from the second number:\",\n \": `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between moon and target (inclusive).\",\n \"constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns ------- moon_dict :\",\n \".moon import moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ =\",\n \"to simple numpy arrays of the same shape and # broadcast these to\",\n \">= min_time) or (t.time() <= max_time) for t in times.datetime]) except BaseException: mask\",\n \"'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer,\",\n \"self.min is not None: mask = self.min <= solar_separation elif self.min is not\",\n \"`~astropy.units.Quantity` The altitude of the sun below which it is considered to be\",\n \"``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result on the ``observer``\",\n \"None and self.min is not None: mask = self.min <= separation elif self.min\",\n \"constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max if self.min\",\n \"np.logical_and.reduce(applied_constraints) colnames = ['target name', 'ever observable', 'always observable', 'fraction of time observable']\",\n \"observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate moon altitude\",\n \"\\\"\\\"\\\" Consider nighttime as time between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg,\",\n \"Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint : bool\",\n \"+ times.shape except BaseException: # must be scalar timekey = (times.jd,) # make\",\n \"on which to compute the phase. For example, the system could be an\",\n \"`None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit.\",\n \"containing three key-value pairs. (1) 'times' contains the times for the computations, (2)\",\n \"90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets):\",\n \"self.max elif self.max is None and self.min is not None: mask = self.min\",\n \"__init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the\",\n \"in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which\",\n \"This will be passed as the first argument into `~astroplan.time_grid_from_range`. If a single\",\n \"\\\"\\\"\\\" Constrain observations to times in some range of phases for a periodic\",\n \"broadcasting times and targets against each other if targets is not None: #\",\n \"no limit. max : float or `None` (optional) Maximum acceptable fractional illumination (inclusive).\",\n \"cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries\",\n \"------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times' contains the\",\n \"until astropy PR #5897 is released # which should be astropy 1.3.2 moon\",\n \"targets to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in\",\n \"time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets`` are observable for a\",\n \"`~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max\",\n \"max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer,\",\n \"= time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed for\",\n \"first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask\",\n \"observable between 23:50 and 04:08 local time: >>> from astroplan import Observer >>>\",\n \"\\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or\",\n \"# Should be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint):\",\n \"targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord object. Accessing\",\n \"is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction\",\n \"self.min is not None: mask = self.min <= separation elif self.min is not\",\n \"cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure\",\n \"constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints]\",\n \"if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert times to tuple for\",\n \"\\\"\\\"\\\" self.min = min self.max = max if self.min is None and self.max\",\n \"frame, so the separation is as-seen # by the observer. # 'get_sun' returns\",\n \"between moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or\",\n \"coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets\",\n \"against each other if targets is not None: # broadcasting times v targets\",\n \"the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {} # convert\",\n \"min self.max = max def compute_constraint(self, times, observer, targets): # use get_body rather\",\n \"observer, targets, force_zero_pressure=False): \\\"\\\"\\\" Calculate alt/az for ``target`` at times linearly spaced between\",\n \"the target. .. note:: This can misbehave if you try to constrain negative\",\n \"whether or not each target is observable in the time range given the\",\n \"an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard library\",\n \"= ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or\",\n \"np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the\",\n \"\\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\",\",\n \"Maximum acceptable separation between Sun and target (inclusive). `None` indicates no limit. \\\"\\\"\\\"\",\n \"(localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are\",\n \"# which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to\",\n \"(t.time() <= max_time) for t in times.datetime]) except BaseException: mask = np.bool_((times.datetime.time() >=\",\n \": bool Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing\",\n \"= [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in\",\n \"tab def min_best_rescale(vals, min_val, max_val, less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to\",\n \"must be specified as datetime.time objects.\\\") if self.max is not None: if not\",\n \"of ingress and egress times for ``N`` events, with shape (``N``, 2). Returns\",\n \"is not None else 0.0 self.max = max if max is not None\",\n \"and (3) contains the moon illumination for those times. \\\"\\\"\\\" if not hasattr(observer,\",\n \"Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of\",\n \"max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive).\",\n \"observability_table : `~astropy.table.Table` A Table containing the observability information for each of the\",\n \"key to store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time`\",\n \"`~astropy.time.Time` (optional) Array of mid-event times on which to test the constraints times_ingress_egress\",\n \"dt >>> subaru = Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and\",\n \"here, which causes small <1 deg # innacuracies, but it is needed until\",\n \"latitude of target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min self.max\",\n \"\\\"\\\"\\\" Consider nighttime as time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg,\",\n \"\\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0) or (min > 1) or\",\n \"constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time sequence, with\",\n \"The times to compute the constraint observer : `~astroplan.Observer` the observaton location from\",\n \"months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with\",\n \"to between 0 and 1, with the best (1) and worst (2.25). All\",\n \"\\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( #\",\n \"\\\"\\\"\\\" Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the\",\n \"each of the ``targets``. The table contains four columns with information about the\",\n \"about (rescales to 1) less_than_min : 0 or 1 what is returned for\",\n \"= {} # convert times to tuple for hashing aakey = _make_cache_key(times, 'moon')\",\n \"# Licensed under a 3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify\",\n \"a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or\",\n \"compute_constraint(self, times, observer, targets): # first is the moon up? cached_moon = _get_moon_data(times,\",\n \"= False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table =\",\n \"not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified as\",\n \"return 0 below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale\",\n \"secant of the zenith angle. .. note:: The ``max`` and ``min`` arguments appear\",\n \"self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times,\",\n \"in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)\",\n \"System on which to compute the phase. For example, the system could be\",\n \"whether constraints are met between test times in ``time_range`` by checking constraint at\",\n \"checking constraint at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns\",\n \"np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1, 2.25,\",\n \"]) \\\"\\\"\\\" rescaled = (vals - min_val) / (max_val - min_val) below =\",\n \"target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr\",\n \"All values outside the range should return 0. >>> from astroplan.constraints import min_best_rescale\",\n \"do the real work of computing the constraint. Subclasses override this. Parameters ----------\",\n \"max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation\",\n \"the moon illumination for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache =\",\n \"if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find solar altitude at\",\n \"observable for a specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints :\",\n \"times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for\",\n \"observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class\",\n \"t in times.datetime]) except BaseException: # use np.bool so shape queries don't cause\",\n \"An example use case for this class would be to associate an acceptable\",\n \"on which to test the constraint. observer : `~astroplan.Observer` The observer who has\",\n \"* 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints return tab\",\n \"a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which to\",\n \"time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints are met\",\n \"to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine\",\n \"the ``min_val`` goes to zero. Parameters ---------- vals : array-like the values that\",\n \"if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time\",\n \"below = vals < min_val above = vals > max_val rescaled[below] = less_than_min\",\n \"\\\"AirmassConstraint.\\\") return mask else: if self.max is None: raise ValueError(\\\"Cannot have a float\",\n \"not None and self.max is not None: mask = ((self.min <= separation) &\",\n \"along the second. Otherwise, we rely on broadcasting the shapes together using standard\",\n \"mask = (self.max >= illumination) | moon_down_mask elif self.max is None and self.min\",\n \"@u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude\",\n \"TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within certain time limits. An example\",\n \"\\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\",\",\n \"eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system =\",\n \"Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 =\",\n \"that January maps to 1, February maps to 2, etc. \\\"\\\"\\\" # TODO:\",\n \"= dict(times=times, illum=illumination, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def\",\n \"not None: mask = self.max >= moon_separation elif self.max is None and self.min\",\n \"time range with a specific observing block. This can be useful if not\",\n \"optional Ephemeris to use. If not given, use the one set with `~astropy.coordinates.solar_system_ephemeris`\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0]\",\n \"``max_val`` equal 1 Examples -------- rescale an array of altitudes to be between\",\n \"cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is\",\n \"max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"'altaz' contains the corresponding alt/az coordinates at those times. \\\"\\\"\\\" if not hasattr(observer,\",\n \"True, grids the constraint result with targets along the first index and times\",\n \"of the PhaseConstraint must be within' ' the interval [0, 1).') self.min =\",\n \"``times`` for whether or not the target is ever observable at each time,\",\n \"observations on orbital phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent\",\n \": `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}\",\n \"coordinates at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} #\",\n \"array of altitudes to be between 0 and 1, with the best (60)\",\n \"rescale should return 0 below 35 and 1 above 60. >>> from astroplan.constraints\",\n \"time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about observability for all the\",\n \"period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified,\",\n \"def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_primary_eclipse(times) return mask class SecondaryEclipseConstraint(Constraint): \\\"\\\"\\\"\",\n \"(e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ----------\",\n \"constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer who\",\n \"__init__(self, min=None, max=None, boolean_constraint=True): if min is None: self.min = -90*u.deg else: self.min\",\n \"def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and\",\n \"moon_illumination from .utils import time_grid_from_range from .target import get_skycoord __all__ = [\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\",\",\n \"targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) &\",\n \"all the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for\",\n \"targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def\",\n \"times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of\",\n \"constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing = times_ingress_egress[:, 0] times_egr =\",\n \"targets : sequence of `~astroplan.Target` The targets on which to apply the constraints.\",\n \"max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates\",\n \"less than ``min_val`` should also return one, in some cases it should return\",\n \"no limit. ephemeris : str, optional Ephemeris to use. If not given, use\",\n \"broadcast these to find the correct shape shp1, shp2 = times.shape, targets.shape x\",\n \"observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about observability\",\n \"this class Parameters ---------- observer : `~astroplan.Observer` the observation location from which to\",\n \"Time-grid spacing grid_times_targets : bool if True, grids the constraint result with targets\",\n \"x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x,\",\n \"acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris\",\n \"as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range from .target\",\n \"this initializer to support the common case for users who care about the\",\n \"from which to apply the constraints targets : sequence of `~astroplan.Target` The targets\",\n \"if force_zero_pressure: observer.pressure = observer_old_pressure return observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate\",\n \"Subclasses override this. Parameters ---------- times : `~astropy.time.Time` The times to compute the\",\n \"min=1, boolean_constraint=True): self.min = min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self,\",\n \"{} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if self.force_pressure_zero:\",\n \"Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it\",\n \"routine will provide an appropriate, hashable, key to store these calculations in a\",\n \"2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing\",\n \"subclass System on which to compute the phase. For example, the system could\",\n \"list of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure\",\n \"raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") if self.max is not\",\n \">= moon_separation elif self.max is None and self.min is not None: mask =\",\n \"or a maximum time.\\\") if self.min is not None: if not isinstance(self.min, datetime.time):\",\n \"if aakey not in observer._altaz_cache: try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure =\",\n \"between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time import\",\n \"Target or list of targets times : `~astropy.time.Time` (optional) Array of times on\",\n \"__metaclass__ = ABCMeta def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute\",\n \"23:50 and 04:08 local time: >>> from astroplan import Observer >>> from astroplan.constraints\",\n \"def __call__(self, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for\",\n \"min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target\",\n \"times between 23:50 and 04:08 local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8))\",\n \">>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min <\",\n \": `~astropy.time.Time` (optional) Array of times on which to test the constraint time_range\",\n \"shapes together using standard numpy rules. Returns ------- constraint_result : 1D or 2D\",\n \"between civil twilights (-6 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs):\",\n \"shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1, strides=[0] *\",\n \"ephemeris @classmethod def dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults\",\n \"for an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function, unicode_literals) # Standard\",\n \"to test the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``.\",\n \"<= alt uppermask = alt <= self.max return lowermask & uppermask else: return\",\n \"must be specified as datetime.time objects.\\\") def compute_constraint(self, times, observer, targets): timezone =\",\n \"observer.timezone if self.min is not None: min_time = self.min else: min_time = self.min\",\n \"is_24hr_table: tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime\",\n \"list of targets. Returns ------- cache_key : tuple A hashable tuple for use\",\n \"those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times\",\n \"mask = ((self.min <= moon_separation) & (moon_separation <= self.max)) else: raise ValueError(\\\"No max\",\n \"as ``targets`` for whether or not each target is observable in the time\",\n \"dark(cls, min=None, max=0.25, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum\",\n \"None and self.min is not None: mask = self.min <= moon_separation elif self.min\",\n \"= Observer.at_site(\\\"Subaru\\\", timezone=\\\"US/Hawaii\\\") >>> # bound times between 23:50 and 04:08 local Hawaiian\",\n \"upper bounds on time sequence, with spacing ``time_resolution``. This will be passed as\",\n \"if aakey not in observer._meridian_transit_cache: meridian_transit_times = observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return\",\n \"mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array\",\n \"maximum Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination\",\n \"combination of ``times`` and ``targets``. Often, we wish to store expensive calculations for\",\n \"limit. Parameters ---------- max : float or `None` Maximum airmass of the target.\",\n \"indicates no limit. max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit.\",\n \"is not None: if not isinstance(self.min, Time): raise TypeError(\\\"Time limits must be specified\",\n \"uppermask = alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min,\",\n \"force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below\",\n \"(between zero and one), where the ``max_val`` goes to one, and the ``min_val``\",\n \"each month that a target is observable, one set per target. These integers\",\n \"numpy.lib.stride_tricks import as_strided # Package from .moon import moon_illumination from .utils import time_grid_from_range\",\n \"= [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour,\",\n \"limit. max : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target\",\n \"targets is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return\",\n \"the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \\\"\\\"\\\"\",\n \"with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min = min\",\n \"# moon.separation(targets) is NOT the same as targets.separation(moon) # the former calculates the\",\n \"Array of mid-event times on which to test the constraints times_ingress_egress : `~astropy.time.Time`\",\n \"the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer\",\n \"``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if not\",\n \"0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled = (vals - min_val) / (max_val -\",\n \"+FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled =\",\n \"is_event_observable(constraints, observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable at\",\n \"a score (between zero and one), where the ``min_val`` goes to one, and\",\n \"This avoids errors in the altitude of the Sun that can occur when\",\n \"editors - the order matters here # moon.separation(targets) is NOT the same as\",\n \"numpy rules. Returns ------- constraint_result : 1D or 2D array of float or\",\n \"max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint\",\n \"= observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) # make sure the\",\n \"<= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return\",\n \"max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max = max if self.min is None and\",\n \"objects, or from observer if self.min is not None: timezone = self.min.tzinfo elif\",\n \"astropy.time import Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'),\",\n \"event_observable : `~numpy.ndarray` Array of booleans of same length as ``times`` for whether\",\n \"cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination =\",\n \"self.min) & (phase <= self.max), (phase >= self.min) | (phase <= self.max)) return\",\n \"times, observer, targets): # removed the location argument here, which causes small <1\",\n \"bool The constraints, with targets along the first index and times along the\",\n \"(``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans of same length\",\n \">>> from astroplan.constraints import max_best_rescale >>> import numpy as np >>> altitudes =\",\n \"could be an eclipsing or non-eclipsing binary, or exoplanet system. min : float\",\n \"time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are\",\n \"or bool The constraints. If 2D with targets along the first index and\",\n \"implementation the airmass is approximated by the secant of the zenith angle. ..\",\n \"constraint observer : `~astroplan.Observer` the observaton location from which to apply the constraints\",\n \"Default is zero. max : float (optional) Maximum phase (inclusive) on interval [0,\",\n \"targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple\",\n \"time_range is not None: times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets)\",\n \"A Table containing the observability information for each of the ``targets``. The table\",\n \"will also be present if the ``time_range`` is given as a scalar. It\",\n \"it is needed until astropy PR #5897 is released # which should be\",\n \"of floats between 0 and 1 inclusive rescaled so that ``vals`` equal to\",\n \"is not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified\",\n \"astropy PR #5897 is released # which should be astropy 1.3.2 moon =\",\n \"twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets): if\",\n \"targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer\",\n \"if min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time for\",\n \"the order matters here # moon.separation(targets) is NOT the same as targets.separation(moon) #\",\n \"self.periodic_event.phase(times) mask = np.where(self.max > self.min, (phase >= self.min) & (phase <= self.max),\",\n \": `~astropy.time.Time` (optional) Array of mid-event times on which to test the constraints\",\n \"``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns -------\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints,\",\n \"mask = ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise\",\n \"no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive).\",\n \"in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters\",\n \"so that ``vals`` equal to ``max_val`` equal 0 and those equal to ``min_val``\",\n \"mask = self.min <= moon_separation elif self.min is not None and self.max is\",\n \"altitude az and illumination for an array of times for ``observer``. Cache the\",\n \"= np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines\",\n \"ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation\",\n \"return one, in some cases it should return zero) Returns ------- array of\",\n \"targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask =\",\n \"the Sun is below the horizon and the corrections for atmospheric refraction return\",\n \"the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``.\",\n \"targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1)\",\n \"also satisfied if the Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None):\",\n \"< min_val above = vals > max_val rescaled[below] = 0 rescaled[above] = greater_than_max\",\n \"0.25 and a maximum of 0.65 Parameters ---------- min : float or `None`\",\n \"time to be within certain time limits. An example use case for this\",\n \"cache_key : tuple A hashable tuple for use as a cache key \\\"\\\"\\\"\",\n \"return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic plane and\",\n \">>> from astroplan import Observer >>> from astropy.time import Time >>> subaru =\",\n \"``targets`` for whether or not each target is observable in the time range\",\n \"``targets`` over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters\",\n \"{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The observer\",\n \"an acceptable time range with a specific observing block. This can be useful\",\n \"= 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times)) observer._moon_cache[aakey] = dict(times=times, illum=illumination, altaz=altaz)\",\n \"Minimum acceptable separation between moon and target (inclusive). `None` indicates no limit. max\",\n \"of times on which to test the constraint observer : `~astroplan.Observer` The observer\",\n \"Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \\\"\\\"\\\"\",\n \"__init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System\",\n \"\\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year # needed for\",\n \"---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The observer\",\n \"the phase. For example, the system could be an eclipsing or non-eclipsing binary,\",\n \"hashing aakey = _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure:\",\n \"# 'get_sun' returns ICRS coords. sun = get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets)\",\n \"not None and self.max is not None: mask = ((self.min <= illumination) &\",\n \"score (between zero and one), where the ``max_val`` goes to one, and the\",\n \"= (times.jd,) # make hashable thing from targets coords try: if hasattr(targets, 'frame'):\",\n \"class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def\",\n \"s = set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer,\",\n \"compute_constraint(self, times, observer, targets): \\\"\\\"\\\" Actually do the real work of computing the\",\n \"- max_val) / (min_val - max_val) below = vals < min_val above =\",\n \"the rescale should return 0 below 35 and 1 above 60. >>> from\",\n \"per target. These integers are 1-based so that January maps to 1, February\",\n \"max_val : float best value cared about (rescales to 1) less_than_min : 0\",\n \"cls(min, max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint`\",\n \"**kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults\",\n \"**kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults\",\n \"force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey]\",\n \"on which to test the constraint observer : `~astroplan.Observer` The observer who has\",\n \"= _get_moon_data(times, observer) moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask =\",\n \"compute_constraint(self, times, observer, targets): timezone = None # get timezone from time objects,\",\n \"hasattr(constraints, '__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method\",\n \": `~astropy.units.Quantity` The altitude of the sun below which it is considered to\",\n \"'-01-01', str(_current_year) + '-12-31'] ) def _make_cache_key(times, targets): \\\"\\\"\\\" Make a unique key\",\n \"illumination) | moon_down_mask elif self.max is None and self.min is not None: mask\",\n \"= observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets, grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times,\",\n \"at linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observability_table\",\n \"shape as would result from # broadcasting times and targets against each other\",\n \"times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def\",\n \"3-clause BSD style license - see LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine\",\n \"times_ing = times_ingress_egress[:, 0] times_egr = times_ingress_egress[:, 1] applied_constraints_ing = [constraint(observer, target, times=times_ing,\",\n \"0) max_val : float best value cared about (rescales to 1) less_than_min :\",\n \"an eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum\",\n \"Constrain observations to times in some range of phases for a periodic event\",\n \"removed the location argument here, which causes small <1 deg # innacuracies, but\",\n \"constrain observations on orbital phases between 0.4 and 0.6, >>> from astroplan import\",\n \"in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the\",\n \"Should be implemented on each subclass of Constraint raise NotImplementedError class AltitudeConstraint(Constraint): \\\"\\\"\\\"\",\n \"index and times along the second. \\\"\\\"\\\" # Should be implemented on each\",\n \"the second. \\\"\\\"\\\" if times is None and time_range is not None: times\",\n \"(optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates no limit.\",\n \"t.time() <= max_time for t in times.datetime]) except BaseException: # use np.bool so\",\n \"None: self.max = 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self,\",\n \"constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in\",\n \"this. Parameters ---------- times : `~astropy.time.Time` The times to compute the constraint observer\",\n \"for the computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times\",\n \"'times' contains the meridian_transit times. \\\"\\\"\\\" if not hasattr(observer, '_meridian_transit_cache'): observer._meridian_transit_cache = {}\",\n \"location argument here, which causes small <1 deg # innacuracies, but it is\",\n \"alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class\",\n \"1) greater_than_max : 0 or 1 what is returned for ``vals`` above ``max_val``.\",\n \"<= self.max)) & moon_up_mask else: raise ValueError(\\\"No max and/or min specified in \\\"\",\n \"key \\\"\\\"\\\" # make a tuple from times try: timekey = tuple(times.jd) +\",\n \"at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the\",\n \"`~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates no limit.\",\n \"is not None: mask = ((self.min <= separation) & (separation <= self.max)) else:\",\n \"= self.min <= solar_separation elif self.min is not None and self.max is not\",\n \"cls(max_solar_altitude=-12*u.deg, **kwargs) @classmethod def twilight_astronomical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical\",\n \"of the Earth's moon. Constraint is also satisfied if the Moon has set.\",\n \"System which must be in secondary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self,\",\n \"import min_best_rescale >>> import numpy as np >>> airmasses = np.array([1, 1.5, 2,\",\n \"It also contains metadata entries ``'times'`` (with an array of all the times),\",\n \"self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min\",\n \"cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min\",\n \"thing from targets coords try: if hasattr(targets, 'frame'): # treat as a SkyCoord\",\n \"can be useful if not all observing blocks are valid over the time\",\n \"0.25 Parameters ---------- min : float or `None` (optional) Minimum acceptable fractional illumination\",\n \"<= max_time) # If time boundaries straddle midnight: else: try: mask = np.array([(t.time()\",\n \"is 0.5 hours. Returns ------- ever_observable : list List of booleans of same\",\n \"def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\"\",\n \"for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)\",\n \"Observer >>> from astroplan.constraints import LocalTimeConstraint >>> import datetime as dt >>> subaru\",\n \"time observable'``. The column ``'time observable'`` will also be present if the ``time_range``\",\n \"**kwargs): \\\"\\\"\\\" Consider nighttime as time between astronomical twilights (-18 degrees). \\\"\\\"\\\" return\",\n \"max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None else self.max mask = np.logical_and(times >\",\n \"constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max = max if self.min is\",\n \"= cached_moon['illum'] if self.min is None and self.max is not None: mask =\",\n \"self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz =\",\n \"`None` indicates no limit. min : float or `None` Minimum airmass of the\",\n \"a 24 hour period centered on that time. time_grid_resolution : `~astropy.units.Quantity` (optional) If\",\n \"rescale an array of altitudes to be between 0 and 1, with the\",\n \"and self.min is not None: mask = (self.min <= illumination) & moon_up_mask elif\",\n \"List of sets of unique integers representing each month that a target is\",\n \"0 below 35 and 1 above 60. >>> from astroplan.constraints import max_best_rescale >>>\",\n \"raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") def compute_constraint(self, times, observer,\",\n \"max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None` indicates no\",\n \"in the altitude of the Sun that can occur when the Sun is\",\n \"the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key\",\n \"astronomical twilights (-18 degrees). \\\"\\\"\\\" return cls(max_solar_altitude=-18*u.deg, **kwargs) def _get_solar_altitudes(self, times, observer, targets):\",\n \"or `None` (optional) Maximum acceptable separation between Sun and target (inclusive). `None` indicates\",\n \"None: timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if\",\n \"illumination = cached_moon['illum'] if self.min is None and self.max is not None: mask\",\n \"observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects defining observational constraints. \\\"\\\"\\\"\",\n \"minimum of 0.65 and no maximum Parameters ---------- min : float or `None`\",\n \"constraints in ``constraints_list`` for a particular ``observer``. Parameters ---------- constraints : list or\",\n \"times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in\",\n \"def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) alt = cached_altaz['altaz'].alt\",\n \"be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude\",\n \"each time in ``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters\",\n \"specified in \\\" \\\"SunSeparationConstraint.\\\") return mask class MoonSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between\",\n \"import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import numpy as\",\n \"array of float or bool The constraints. If 2D with targets along the\",\n \"the observaton location from which to apply the constraints targets : sequence of\",\n \"as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not None: if not isinstance(self.max, Time):\",\n \"is not None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone\",\n \"0 # find solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude\",\n \"def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines if the ``targets`` are\",\n \"airmass be \\\"better than 2\\\", i.e. at a higher altitude than airmass=2:: AirmassConstraint(2)\",\n \"best value cared about (rescales to 1) greater_than_max : 0 or 1 what\",\n \"in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the\",\n \"observer._moon_cache[aakey] def _get_meridian_transit_times(times, observer, targets): \\\"\\\"\\\" Calculate next meridian transit for an array\",\n \"timekey = tuple(times.jd) + times.shape except BaseException: # must be scalar timekey =\",\n \"zero. Parameters ---------- vals : array-like the values that need to be rescaled\",\n \"times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A function to determine whether ``targets`` are always observable\",\n \"care about the upper limit on the airmass (``max``) and not the lower\",\n \"timezone = self.min.tzinfo elif self.max is not None: timezone = self.max.tzinfo if timezone\",\n \"self.min <= separation elif self.min is not None and self.max is not None:\",\n \"def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The altitude of\",\n \"limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first\",\n \"(which is set to 'builtin' by default). \\\"\\\"\\\" self.min = min self.max =\",\n \"max_time = datetime.time(23, 59, 59) # If time limits occur on same day:\",\n \"boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time() <=\",\n \"compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET? time_range\",\n \"and target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris to\",\n \"or list of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``.\",\n \"if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey\",\n \"we want. moon_separation = moon.separation(targets) if self.min is None and self.max is not\",\n \"Returns ------- time_dict : dict Dictionary containing a key-value pair. 'times' contains the\",\n \"pressure to zero for solar altitude calculations. This avoids errors in the altitude\",\n \"as would result from # broadcasting times and targets against each other if\",\n \"a boolean (True for within the limits and False for outside). If False,\",\n \"__init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time` Earliest local time (inclusive).\",\n \"valid over the time limits used in calls to `is_observable` or `is_always_observable`. \\\"\\\"\\\"\",\n \"raise ValueError(\\\"You must at least supply either a minimum or a \\\" \\\"maximum\",\n \"+FLOAT_CMP array([ 0. , 0. , 0.2, 0.4, 0.8, 1. ]) \\\"\\\"\\\" rescaled\",\n \"a = as_strided(x, shape=shp1, strides=[0] * len(shp1)) b = as_strided(x, shape=shp2, strides=[0] *\",\n \"[constraints] if times is not None: applied_constraints = [constraint(observer, target, times=times, grid_times_targets=True) for\",\n \"\\\"\\\"\\\" self.min = min self.max = max self.ephemeris = ephemeris def compute_constraint(self, times,\",\n \"np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines\",\n \"that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>>\",\n \"return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"from astroplan import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\")\",\n \"be an eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional)\",\n \"in some range of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries).\",\n \"if the end user # disables gridding and re-shapes the coords themselves #\",\n \"`None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25,\",\n \"# removed the location argument here, which causes small <1 deg # innacuracies,\",\n \"initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of 0.25 and a maximum\",\n \"to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not in observer._altaz_cache:\",\n \"(phase <= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\"\",\n \"= time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def is_event_observable(constraints,\",\n \"pressure. Returns ------- altaz_dict : dict Dictionary containing two key-value pairs. (1) 'times'\",\n \"None: mask = self.min <= solar_separation elif self.min is not None and self.max\",\n \"events, with shape (``N``, 2). Returns ------- event_observable : `~numpy.ndarray` Array of booleans\",\n \"that can occur when the Sun is below the horizon and the corrections\",\n \"`~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of 0.25 Parameters ----------\",\n \"acceptable separation between Sun and target (inclusive). `None` indicates no limit. max :\",\n \"rescaled to be between 0 and 1 min_val : float worst acceptable value\",\n \"trigonometric # altitude calculations. applied_constraints = [constraint(observer, targets, times=times, grid_times_targets=True) for constraint in\",\n \"\\\"\\\"\\\" return cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time\",\n \"example, the system could be an eclipsing or non-eclipsing binary, or exoplanet system.\",\n \"BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey def _get_altaz(times, observer, targets, force_zero_pressure=False):\",\n \"BaseException: # must be scalar timekey = (times.jd,) # make hashable thing from\",\n \"targets. Returns ------- cache_key : tuple A hashable tuple for use as a\",\n \"solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class\",\n \"some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity`\",\n \"& (separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\"\",\n \"def max_best_rescale(vals, min_val, max_val, greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to be\",\n \"1], where 0 is the min altitude and 1 is the max. \\\"\\\"\\\"\",\n \"ephemeris=self.ephemeris) # note to future editors - the order matters here # moon.separation(targets)\",\n \"= max self.ephemeris = ephemeris def compute_constraint(self, times, observer, targets): # removed the\",\n \"separation between moon and target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity`\",\n \"---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase.\",\n \"to use. If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is\",\n \"linearly spaced between the two times in ``time_range`` with grid spacing ``time_resolution`` for\",\n \"queries don't cause problems mask = np.bool_(min_time <= times.datetime.time() <= max_time) # If\",\n \"the first index and times along the second. \\\"\\\"\\\" # Should be implemented\",\n \"if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey] def _get_moon_data(times, observer, force_zero_pressure=False): \\\"\\\"\\\" Calculate\",\n \"`~astroplan.Observer` The observer who has constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target\",\n \"(optional) Lower and upper bounds on time sequence, with spacing ``time_resolution``. This will\",\n \"(scalar) time, the table will be for a 24 hour period centered on\",\n \"tab = table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range\",\n \"observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class for objects\",\n \"and self.max is not None: mask = self.max >= moon_separation elif self.max is\",\n \"Maximum airmass of the target. `None` indicates no limit. min : float or\",\n \"1). Default is one. Examples -------- To constrain observations on orbital phases between\",\n \": `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if True, grids the constraint result\",\n \"February maps to 2, etc. \\\"\\\"\\\" # TODO: This method could be sped\",\n \"'__len__'): constraints = [constraints] times = time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could\",\n \"is below the horizon and the corrections for atmospheric refraction return nonsense values.\",\n \"limits and False for outside). If False, the constraint returns a float on\",\n \"between Sun and target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min\",\n \"astroplan import Observer >>> from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>>\",\n \"the constraints. Returns ------- constraint_result : 2D array of float or bool The\",\n \"else: mx = self.max mi = 1 if self.min is None else self.min\",\n \"Galactic plane and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ----------\",\n \"-------- To create a constraint that requires the airmass be \\\"better than 2\\\",\",\n \"(3) contains the moon illumination for those times. \\\"\\\"\\\" if not hasattr(observer, '_moon_cache'):\",\n \"return cls(min, max, **kwargs) @classmethod def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a\",\n \"scalar timekey = (times.jd,) # make hashable thing from targets coords try: if\",\n \"force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.moon_altaz(times) illumination = np.array(moon_illumination(times))\",\n \"is not specified, defaults to current year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If\",\n \"which causes small <1 deg # innacuracies, but it is needed until astropy\",\n \"a constraint that requires the airmass be \\\"better than 2\\\", i.e. at a\",\n \"self.max is None: raise ValueError(\\\"You must at least supply either a minimum or\",\n \"else 1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max\",\n \"all the times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``).\",\n \"observable between 2016-03-28 and 2016-03-30: >>> from astroplan import Observer >>> from astropy.time\",\n \"array ``vals`` to be a score (between zero and one), where the ``min_val``\",\n \"is returned for ``vals`` below ``min_val``. (in some cases anything less than ``min_val``\",\n \"binaries). \\\"\\\"\\\" def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent`\",\n \"given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s)\",\n \"as targets.separation(moon) # the former calculates the separation in the frame of the\",\n \"table.Table(names=colnames, data=[target_names, ever_obs, always_obs, frac_obs]) if times is None and time_range is not\",\n \"Forcefully use 0 pressure. Returns ------- moon_dict : dict Dictionary containing three key-value\",\n \"to times during secondary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system\",\n \"with the best (60) going to 1 and worst (35) going to 0.\",\n \"constraint_result : 2D array of float or bool The constraints, with targets along\",\n \"`~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For example, the\",\n \"the ``time_range`` is given as a scalar. It also contains metadata entries ``'times'``\",\n \"Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no limit. max :\",\n \"# broadcast these to find the correct shape shp1, shp2 = times.shape, targets.shape\",\n \"times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable at each time in ``times``,\",\n \"bounds on time sequence If ``time_range`` is not specified, defaults to current year\",\n \"to 1) greater_than_max : 0 or 1 what is returned for ``vals`` above\",\n \"self.min is None and self.max is not None: mask = (self.max >= illumination)\",\n \"times, observer, targets): solar_altitude = self._get_solar_altitudes(times, observer, targets) mask = solar_altitude <= self.max_solar_altitude\",\n \"centred frame, so the separation is as-seen # by the observer. # 'get_sun'\",\n \"= ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\\\"No max and/or\",\n \"observations to targets that are observable between 2016-03-28 and 2016-03-30: >>> from astroplan\",\n \"or exoplanet system. min : float (optional) Minimum phase (inclusive) on interval [0,\",\n \"where 0 is the min altitude and 1 is the max. \\\"\\\"\\\" def\",\n \"to ``min_val`` equal 0 and those equal to ``max_val`` equal 1 Examples --------\",\n \"for ``target`` at times linearly spaced between the two times in ``time_range`` with\",\n \"test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets. Returns -------\",\n \"max if max is not None else 1.0 def compute_constraint(self, times, observer=None, targets=None):\",\n \"(optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates no limit.\",\n \"self.max >= moon_separation elif self.max is None and self.min is not None: mask\",\n \"which should be astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future\",\n \"= [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month for t\",\n \"name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time observable'``. The column ``'time\",\n \"with targets along the first index and times along the second. \\\"\\\"\\\" if\",\n \"not isinstance(self.max, Time): raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\")\",\n \"= ((self.min <= solar_separation) & (solar_separation <= self.max)) else: raise ValueError(\\\"No max and/or\",\n \"least supply either a minimum or a maximum time.\\\") if self.min is not\",\n \"broadcasting times v targets is slow due to # complex nature of these\",\n \"Array of times on which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target\",\n \"if the Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters\",\n \"of the ``targets``. The table contains four columns with information about the target\",\n \"corresponding alt/az coordinates at those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache =\",\n \"= datetime.time(0, 0, 0) if self.max is not None: max_time = self.max else:\",\n \"\\\"\\\"\\\" self.min = min self.max = max def compute_constraint(self, times, observer, targets): separation\",\n \"alt uppermask = alt <= self.max return lowermask & uppermask else: return max_best_rescale(alt,\",\n \"raise TypeError(\\\"Time limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is\",\n \"constraints ``constraints`` targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range\",\n \"grid_times_targets=False) observer._altaz_cache[aakey] = dict(times=times, altaz=altaz) finally: if force_zero_pressure: observer.pressure = observer_old_pressure return observer._altaz_cache[aakey]\",\n \"None and self.max is not None: mask = ((self.min <= solar_separation) & (solar_separation\",\n \"min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable\",\n \"time boundaries straddle midnight: else: try: mask = np.array([(t.time() >= min_time) or (t.time()\",\n \"as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses, 1,\",\n \"of times for ``targets`` and ``observer``. Cache the result on the ``observer`` object.\",\n \"# centred frame, so the separation is as-seen # by the observer. #\",\n \"and 1 inclusive rescaled so that ``vals`` equal to ``max_val`` equal 0 and\",\n \"self.max is not None: mask = (self.max >= illumination) | moon_down_mask elif self.max\",\n \"targets): \\\"\\\"\\\" Actually do the real work of computing the constraint. Subclasses override\",\n \"# use get_body rather than get sun here, since # it returns the\",\n \"targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not None:\",\n \"def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information\",\n \"(1) and worst (2.25). All values outside the range should return 0. >>>\",\n \"`~astropy.table.Table` A Table containing the observability information for each of the ``targets``. The\",\n \"= ((self.min <= illumination) & (illumination <= self.max)) & moon_up_mask else: raise ValueError(\\\"No\",\n \"mask = ((self.min <= separation) & (separation <= self.max)) else: raise ValueError(\\\"No max\",\n \"time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting operations are relatively\",\n \"attribute of the frame data should be unique and is # quicker than\",\n \"in the frame of the moon coord # which is GCRS, and that\",\n \"with information about the target and it's observability: ``'target name'``, ``'ever observable'``, ``'always\",\n \"min_time < max_time: try: mask = np.array([min_time <= t.time() <= max_time for t\",\n \"the best (60) going to 1 and worst (35) going to 0. For\",\n \"not None: timezone = self.max.tzinfo if timezone is None: timezone = observer.timezone if\",\n \"for constraint in constraints] applied_constraints_egr = [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in\",\n \"to zero for solar altitude calculations. This avoids errors in the altitude of\",\n \"interval [0, 1). Default is zero. max : float (optional) Maximum phase (inclusive)\",\n \"as the first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table\",\n \"as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4,\",\n \"on the interval [0, 1). To constrain observations on orbital phases between 0.6\",\n \"tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints']\",\n \"satisfied if the Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\"\",\n \"reference this combination of ``times`` and ``targets``. Often, we wish to store expensive\",\n \"is a string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey\",\n \"# it returns the Sun's coordinates in an observer # centred frame, so\",\n \"min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a minimum of\",\n \"isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\") def compute_constraint(self,\",\n \"specified as \\\" \\\"astropy.time.Time objects.\\\") if self.max is not None: if not isinstance(self.max,\",\n \"Time >>> import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>>\",\n \"as-seen # by the observer. # 'get_sun' returns ICRS coords. sun = get_body('sun',\",\n \"# assume targets is a string. targkey = (targets,) except BaseException: targkey =\",\n \"min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit. max :\",\n \"= self.compute_constraint(times, observer, targets) # make sure the output has the same shape\",\n \"= time_grid_from_range(time_range, time_grid_resolution) # TODO: This method could be sped up a lot\",\n \"targets are observable for an observer. \\\"\\\"\\\" from __future__ import (absolute_import, division, print_function,\",\n \"arrays of the same shape and # broadcast these to find the correct\",\n \"has the same shape as would result from # broadcasting times and targets\",\n \"(time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True applied_constraints = [constraint(observer, targets, times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True)\",\n \">>> import numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0])\",\n \"= vals < min_val above = vals > max_val rescaled[below] = 0 rescaled[above]\",\n \"= 1 if self.min is None else self.min # values below 1 should\",\n \"is ever observable in the time range given the constraints. \\\"\\\"\\\" if not\",\n \"the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer\",\n \"object. This routine will provide an appropriate, hashable, key to store these calculations\",\n \"TODO: these broadcasting operations are relatively slow # but there is potential for\",\n \"in targets] ever_obs = np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr,\",\n \"than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max\",\n \"observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude)\",\n \"and ``times`` in a cache on an ``observer``` object. This routine will provide\",\n \"must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None,\",\n \": `~astropy.units.Quantity` or `None` (optional) Minimum acceptable separation between Sun and target (inclusive).\",\n \"from astropy.coordinates import get_body, get_sun, get_moon, Galactic, SkyCoord from astropy import table import\",\n \"_current_year = time.localtime().tm_year # needed for backward compatibility _current_year_time_range = Time( # needed\",\n \"None and self.min is not None: mask = self.min <= secz elif self.min\",\n \"= self.min <= alt uppermask = alt <= self.max return lowermask & uppermask\",\n \"def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical twilights (-12 degrees).\",\n \"mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within certain time limits.\",\n \"given the constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or\",\n \"``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer`\",\n \"get_body('sun', times, location=observer.location) solar_separation = sun.separation(targets) if self.min is None and self.max is\",\n \"0 and 1, with the best (1) and worst (2.25). All values outside\",\n \"& (moon_separation <= self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\"\",\n \"------- observability_table : `~astropy.table.Table` A Table containing the observability information for each of\",\n \"and 1, with the best (1) and worst (2.25). All values outside the\",\n \"should return 0. >>> from astroplan.constraints import min_best_rescale >>> import numpy as np\",\n \"note:: The ``max`` and ``min`` arguments appear in the order (max, min) in\",\n \"method could be sped up a lot by dropping to the trigonometric #\",\n \"import time import warnings # Third-party from astropy.time import Time import astropy.units as\",\n \"not given, use the one set with `~astropy.coordinates.solar_system_ephemeris` (which is set to 'builtin'\",\n \"provide an appropriate, hashable, key to store these calculations in a dictionary. Parameters\",\n \"due to # complex nature of these objects. We make # to simple\",\n \"raise ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint):\",\n \": `~astroplan.periodic.PeriodicEvent` or subclass System on which to compute the phase. For example,\",\n \"is not None and self.max is not None: mask = ((self.min <= solar_separation)\",\n \"------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times' contains the\",\n \"The constraints, with targets along the first index and times along the second.\",\n \"self.min is None and self.max is not None: mask = self.max >= separation\",\n \"over the requested ``time_range``, given the constraints in ``constraints_list`` for ``observer``. Parameters ----------\",\n \"`None` Minimum airmass of the target. `None` indicates no limit. boolean_contstraint : bool\",\n \"``min`` arguments appear in the order (max, min) in this initializer to support\",\n \"solar altitude at these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt #\",\n \"acceptable separation between moon and target (inclusive). `None` indicates no limit. ephemeris :\",\n \"observer._altaz_cache = {} # convert times, targets to tuple for hashing aakey =\",\n \"contains the corresponding alt/az coordinates at those times and (3) contains the moon\",\n \"mask = secz <= self.max elif self.max is None and self.min is not\",\n \"primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\" Parameters ---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System\",\n \"on time sequence, with spacing ``time_resolution``. This will be passed as the first\",\n \"at each time in ``times``, given constraints in ``constraints`` for a particular ``observer``.\",\n \"ephemeris : str, optional Ephemeris to use. If not given, use the one\",\n \"grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints,\",\n \"less_than_min=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score (between zero\",\n \"these times altaz = observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude\",\n \"the Sun and some targets. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ----------\",\n \"else: if self.max is None: raise ValueError(\\\"Cannot have a float AirmassConstraint if max\",\n \"is not None: mask = self.max >= solar_separation elif self.max is None and\",\n \"This will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity`\",\n \": `~astropy.units.Quantity` or `None` Minimum altitude of the target (inclusive). `None` indicates no\",\n \": dict Dictionary containing a key-value pair. 'times' contains the meridian_transit times. \\\"\\\"\\\"\",\n \"times=times, time_range=time_range, time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr,\",\n \"target, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) else: times_ing =\",\n \"months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets`` are\",\n \"the target. `None` indicates no limit. min : float or `None` Minimum airmass\",\n \"``min_val`` goes to one, and the ``max_val`` goes to zero. Parameters ---------- vals\",\n \"the distance between the Galactic plane and some targets. \\\"\\\"\\\" def __init__(self, min=None,\",\n \"(inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self, times,\",\n \">>> from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\")\",\n \"If False, the constraint returns a float on [0, 1], where 0 is\",\n \"tends to mishandle negative Parameters ---------- min : `~astropy.units.Quantity` or `None` Minimum altitude\",\n \"[constraint(observer, targets, times=times, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable =\",\n \"egress times for ``N`` events, with shape (``N``, 2). Returns ------- event_observable :\",\n \"store these calculations in a dictionary. Parameters ---------- times : `~astropy.time.Time` Array of\",\n \"Default is 0.5 hours. Returns ------- observable_months : list List of sets of\",\n \": `~astropy.coordinates.SkyCoord` Target or list of targets. Returns ------- cache_key : tuple A\",\n \">>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint = PhaseConstraint(binary, min=0.4, max=0.6) The\",\n \"not hasattr(constraints, '__len__'): constraints = [constraints] if times is not None: applied_constraints =\",\n \"`~astropy.time.Time` Array of times on which to test the constraint. observer : `~astroplan.Observer`\",\n \"the target. `None` indicates no limit. boolean_contstraint : bool Examples -------- To create\",\n \"particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :\",\n \"times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable']\",\n \"or `None` Minimum altitude of the target (inclusive). `None` indicates no limit. max\",\n \"boolean_contstraint : bool Examples -------- To create a constraint that requires the airmass\",\n \"None and self.max is not None: mask = self.max >= separation elif self.max\",\n \"from astropy.time import Time import astropy.units as u from astropy.coordinates import get_body, get_sun,\",\n \"self.max return lowermask & uppermask else: return max_best_rescale(alt, self.min, self.max) class AirmassConstraint(AltitudeConstraint): \\\"\\\"\\\"\",\n \"= observer.altaz(times, get_sun(times)) altitude = altaz.alt # cache the altitude observer._altaz_cache[aakey] = dict(times=times,\",\n \"else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"AirmassConstraint.\\\") return mask else:\",\n \"self.min = min if min is not None else 0.0 self.max = max\",\n \"``times``, given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints :\",\n \"in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets,\",\n \"times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times, targets\",\n \"times = time_grid_from_range(time_range, time_resolution=time_grid_resolution) if grid_times_targets: targets = get_skycoord(targets) # TODO: these broadcasting\",\n \"else: max_time = datetime.time(23, 59, 59) # If time limits occur on same\",\n \"test the constraint time_range : `~astropy.time.Time` (optional) Lower and upper bounds on time\",\n \"and self.max is not None: mask = (self.min <= secz) & (secz <=\",\n \"max_time) # If time boundaries straddle midnight: else: try: mask = np.array([(t.time() >=\",\n \"not the lower limit. Parameters ---------- max : float or `None` Maximum airmass\",\n \"given constraints in ``constraints`` for a particular ``observer``. Parameters ---------- constraints : list\",\n \"= cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <=\",\n \"i.e. at a higher altitude than airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1,\",\n \"force_pressure_zero : bool (optional) Force the pressure to zero for solar altitude calculations.\",\n \": `~astropy.time.Time` (length = 2) Lower and upper bounds on time sequence. time_grid_resolution\",\n \"avoids errors in the altitude of the Sun that can occur when the\",\n \"\\\"\\\"\\\" self.max_solar_altitude = max_solar_altitude self.force_pressure_zero = force_pressure_zero @classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider\",\n \"np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s = set([t.datetime.month\",\n \"and times along the second. \\\"\\\"\\\" if times is None and time_range is\",\n \"{list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on\",\n \"with information about observability for all the ``targets`` over the requested ``time_range``, given\",\n \"constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target : {list,\",\n \"To constrain observations on orbital phases between 0.4 and 0.6, >>> from astroplan\",\n \"specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class MoonIlluminationConstraint(Constraint): \\\"\\\"\\\" Constrain the fractional illumination\",\n \"be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun\",\n \"time_grid_resolution=time_grid_resolution, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) return np.any(constraint_arr, axis=1) def\",\n \"above = vals > max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled\",\n \"constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr)) return constraint_arr def months_observable(constraints, observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\"\",\n \": bool If True, the constraint is treated as a boolean (True for\",\n \"or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time`\",\n \"try: if force_zero_pressure: observer_old_pressure = observer.pressure observer.pressure = 0 altaz = observer.altaz(times, targets,\",\n \"astropy 1.3.2 moon = get_moon(times, ephemeris=self.ephemeris) # note to future editors - the\",\n \"the observation location from which to apply the constraints targets : sequence of\",\n \"is not None: mask = self.min <= separation elif self.min is not None\",\n \"phases between 0.4 and 0.6, >>> from astroplan import PeriodicEvent >>> from astropy.time\",\n \"or list of targets times : `~astropy.time.Time` (optional) Array of times on which\",\n \"argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be for\",\n \"or 1 what is returned for ``vals`` below ``min_val``. (in some cases anything\",\n \"observer.target_meridian_transit_time(times, targets) observer._meridian_transit_cache[aakey] = dict(times=meridian_transit_times) return observer._meridian_transit_cache[aakey] @abstractmethod class Constraint(object): \\\"\\\"\\\" Abstract class\",\n \"linearly-spaced times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months :\",\n \"None and self.max is not None: mask = secz <= self.max elif self.max\",\n \"be unique and is # quicker than accessing the ra attribute. targkey =\",\n \"`~astroplan.Target` The targets on which to apply the constraints. Returns ------- constraint_result :\",\n \"import astropy.units as u >>> binary = PeriodicEvent(epoch=Time('2017-01-01 02:00'), period=1*u.day) >>> constraint =\",\n \"test times in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``.\",\n \"= periodic_event if (min < 0) or (min > 1) or (max <\",\n \"gridding and re-shapes the coords themselves # prior to evaluating multiple constraints. if\",\n \"or list of targets Returns ------- time_dict : dict Dictionary containing a key-value\",\n \"max, **kwargs) @classmethod def bright(cls, min=0.65, max=None, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with\",\n \"else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result =\",\n \"self.min is not None: mask = self.min <= moon_separation elif self.min is not\",\n \"in some cases it should return zero) Returns ------- array of floats between\",\n \"by the secant of the zenith angle. .. note:: The ``max`` and ``min``\",\n \"Observational constraint(s) observer : `~astroplan.Observer` The observer who has constraints ``constraints`` target :\",\n \"single (scalar) time, the table will be for a 24 hour period centered\",\n \"defaults of a minimum of 0.65 and no maximum Parameters ---------- min :\",\n \"illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) def compute_constraint(self,\",\n \"``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of\",\n \"test the constraints times_ingress_egress : `~astropy.time.Time` (optional) Array of ingress and egress times\",\n \"two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the result\",\n \"indicates no limit. boolean_constraint : bool If True, the constraint is treated as\",\n \"times separated by ``time_resolution``. Default is 0.5 hours. Returns ------- observable_months : list\",\n \"0) # doctest: +FLOAT_CMP array([ 1. , 0.6, 0.2, 0. , 0. ])\",\n \"of time observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr,\",\n \"first argument into `~astroplan.time_grid_from_range`. If a single (scalar) time, the table will be\",\n \"If not given, use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to\",\n \"self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Galactic plane\",\n \"objects.\\\") if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time limits\",\n \">>> import numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55,\",\n \"airmass=2:: AirmassConstraint(2) \\\"\\\"\\\" def __init__(self, max=None, min=1, boolean_constraint=True): self.min = min self.max =\",\n \"0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0\",\n \"if not hasattr(observer, '_moon_cache'): observer._moon_cache = {} # convert times to tuple for\",\n \"``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer`\",\n \"Third-party from astropy.time import Time import astropy.units as u from astropy.coordinates import get_body,\",\n \"greater_than_max=1): \\\"\\\"\\\" rescales an input array ``vals`` to be a score (between zero\",\n \"to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE SET?\",\n \"and 1 inclusive rescaled so that ``vals`` equal to ``min_val`` equal 0 and\",\n \"bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets : bool if\",\n \"if max is None: self.max = 90*u.deg else: self.max = max self.boolean_constraint =\",\n \"than get sun here, since # it returns the Sun's coordinates in an\",\n \"local Hawaiian time >>> constraint = LocalTimeConstraint(min=dt.time(23,50), max=dt.time(4,8)) \\\"\\\"\\\" self.min = min self.max\",\n \"observer, targets): # first is the moon up? cached_moon = _get_moon_data(times, observer) moon_alt\",\n \"indicates no limit. boolean_contstraint : bool Examples -------- To create a constraint that\",\n \"= np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest:\",\n \"the time range given the constraints. \\\"\\\"\\\" if not hasattr(constraints, '__len__'): constraints =\",\n \"of targets. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure :\",\n \"\\\"\\\"\\\" Constrain observations to times during primary eclipse. \\\"\\\"\\\" def __init__(self, eclipsing_system): \\\"\\\"\\\"\",\n \"`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets time_range : `~astropy.time.Time` (optional) Lower and\",\n \"shape shp1, shp2 = times.shape, targets.shape x = np.array([1]) a = as_strided(x, shape=shp1,\",\n \"you try to constrain negative altitudes, as the `~astropy.coordinates.AltAz` frame tends to mishandle\",\n \": bool Forcefully use 0 pressure. Returns ------- altaz_dict : dict Dictionary containing\",\n \"`~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates\",\n \"\\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\",\",\n \"one from the second number: >>> constraint = PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event\",\n \"which to test the constraint. targets : `~astropy.coordinates.SkyCoord` Target or list of targets.\",\n \"= set([t.datetime.month for t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets,\",\n \"year (localtime) time_grid_resolution : `~astropy.units.Quantity` (optional) If ``time_range`` is specified, determine whether constraints\",\n \"of ``targets`` and ``times`` in a cache on an ``observer``` object. This routine\",\n \"of 0.25 and a maximum of 0.65 Parameters ---------- min : float or\",\n \"ValueError('The minimum of the PhaseConstraint must be within' ' the interval [0, 1).')\",\n \"[\\\"AltitudeConstraint\\\", \\\"AirmassConstraint\\\", \\\"AtNightConstraint\\\", \\\"is_observable\\\", \\\"is_always_observable\\\", \\\"time_grid_from_range\\\", \\\"GalacticLatitudeConstraint\\\", \\\"SunSeparationConstraint\\\", \\\"MoonSeparationConstraint\\\", \\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\",\",\n \"nature of these objects. We make # to simple numpy arrays of the\",\n \"= self.eclipsing_system.in_secondary_eclipse(times) return mask class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some\",\n \"or `None` Maximum altitude of the target (inclusive). `None` indicates no limit. boolean_constraint\",\n \"moon_alt = cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0\",\n \"\\\"MoonIlluminationConstraint\\\", \\\"LocalTimeConstraint\\\", \\\"PrimaryEclipseConstraint\\\", \\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year\",\n \"max : float or `None` Maximum airmass of the target. `None` indicates no\",\n \"numpy as np >>> airmasses = np.array([1, 1.5, 2, 3, 0]) >>> min_best_rescale(airmasses,\",\n \"targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times,\",\n \"illumination of the Earth's moon. Constraint is also satisfied if the Moon has\",\n \"if not hasattr(constraints, '__len__'): constraints = [constraints] applied_constraints = [constraint(observer, targets, times=times, time_range=time_range,\",\n \"is not None: min_time = self.min else: min_time = self.min = datetime.time(0, 0,\",\n \"indicates no limit. max : `~astropy.units.Quantity` or `None` Maximum altitude of the target\",\n \"times along the second. \\\"\\\"\\\" # Should be implemented on each subclass of\",\n \"max : `~astropy.time.Time` Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain\",\n \"pressure. Returns ------- moon_dict : dict Dictionary containing three key-value pairs. (1) 'times'\",\n \"boolean_constraint def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz =\",\n \"The minimum and maximum phase must be described on the interval [0, 1).\",\n \"or not the target is ever observable at each time, given the constraints.\",\n \"observer, targets, time_range=_current_year_time_range, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Determines which month the specified ``targets`` are observable\",\n \"target is observable, one set per target. These integers are 1-based so that\",\n \"solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the\",\n \"ValueError(\\\"No max and/or min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\"\",\n \"`is_observable` or `is_always_observable`. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min :\",\n \"twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between civil twilights (-6 degrees). \\\"\\\"\\\"\",\n \"class PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some range of phases for\",\n \"# convert times to tuple for hashing aakey = _make_cache_key(times, 'moon') if aakey\",\n \"is not None: if not isinstance(self.max, datetime.time): raise TypeError(\\\"Time limits must be specified\",\n \"1.0 def compute_constraint(self, times, observer=None, targets=None): phase = self.periodic_event.phase(times) mask = np.where(self.max >\",\n \"PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0) or (min\",\n \"primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask =\",\n \"and it's observability: ``'target name'``, ``'ever observable'``, ``'always observable'``, and ``'fraction of time\",\n \"separation is as-seen # by the observer. # 'get_sun' returns ICRS coords. sun\",\n \"= {} aakey = _make_cache_key(times, 'sun') if aakey not in observer._altaz_cache: try: if\",\n \"Compute the constraint for this class Parameters ---------- observer : `~astroplan.Observer` the observation\",\n \"= _make_cache_key(times, 'moon') if aakey not in observer._moon_cache: try: if force_zero_pressure: observer_old_pressure =\",\n \"SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun and some targets. \\\"\\\"\\\" def\",\n \"min_val : float worst acceptable value (rescales to 0) max_val : float best\",\n \"containing the observability information for each of the ``targets``. The table contains four\",\n \"(rescales to 0) max_val : float best value cared about (rescales to 1)\",\n \"dict Dictionary containing two key-value pairs. (1) 'times' contains the times for the\",\n \"floats between 0 and 1 inclusive rescaled so that ``vals`` equal to ``max_val``\",\n \"`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets Returns ------- time_dict : dict Dictionary\",\n \"grid_times_targets : bool if True, grids the constraint result with targets along the\",\n \"observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~datetime.time`\",\n \"* len(shp2)) output_shape = np.broadcast(a, b).shape if output_shape != np.array(result).shape: result = np.broadcast_to(result,\",\n \"times=None, time_range=None, time_grid_resolution=0.5*u.hour, grid_times_targets=False): \\\"\\\"\\\" Compute the constraint for this class Parameters ----------\",\n \"np.newaxis] times, targets = observer._preprocess_inputs(times, targets, grid_times_targets=False) result = self.compute_constraint(times, observer, targets) #\",\n \"and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid spacing grid_times_targets :\",\n \": `~astropy.units.Quantity` or `None` (optional) Maximum acceptable separation between Sun and target (inclusive).\",\n \"cls(min, max, **kwargs) def compute_constraint(self, times, observer, targets): # first is the moon\",\n \"Constrain the observations to targets that are observable between 23:50 and 04:08 local\",\n \"apply the constraints. times : `~astropy.time.Time` The times to compute the constraint. WHAT\",\n \"(1) 'times' contains the times for the computations, (2) 'altaz' contains the corresponding\",\n \"the second. \\\"\\\"\\\" # Should be implemented on each subclass of Constraint raise\",\n \"Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information for each\",\n \"between the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache\",\n \"and self.max is not None: mask = self.max >= separation elif self.max is\",\n \"for constraint in constraints] constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable\",\n \"for an array of times for ``observer``. Cache the result on the ``observer``\",\n \"dictionary. Parameters ---------- times : `~astropy.time.Time` Array of times on which to test\",\n \"in observer._altaz_cache: try: if self.force_pressure_zero: observer_old_pressure = observer.pressure observer.pressure = 0 # find\",\n \"-------- rescale an array of altitudes to be between 0 and 1, with\",\n \"is not None: if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified\",\n \"Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2)\",\n \"time observable'] target_names = [target.name for target in targets] ever_obs = np.any(constraint_arr, axis=1)\",\n \"constraints in ``constraints_list`` for ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational\",\n \"the min altitude and 1 is the max. \\\"\\\"\\\" def __init__(self, min=None, max=None,\",\n \"times : `~astropy.time.Time` (optional) Array of times on which to test the constraint\",\n \"disregarded return min_best_rescale(secz, mi, mx, less_than_min=0) class AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to\",\n \"30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([\",\n \"sped up a lot by dropping to the trigonometric # altitude calculations. if\",\n \"as a cache key \\\"\\\"\\\" # make a tuple from times try: timekey\",\n \"`~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on which to\",\n \"the altitude observer._altaz_cache[aakey] = dict(times=times, altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else:\",\n \"System which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self,\",\n \"import numpy as np >>> altitudes = np.array([20, 30, 40, 45, 55, 70])\",\n \"(inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or `None` (optional) Maximum acceptable\",\n \"40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35, 60) # doctest: +FLOAT_CMP array([ 0.\",\n \"a minimum or a \\\" \\\"maximum time.\\\") if self.min is not None: if\",\n \"# ensure we have a (1, 1) shape coord targets = SkyCoord(np.tile(targets, 1))[:,\",\n \"is given as a scalar. It also contains metadata entries ``'times'`` (with an\",\n \"function to determine whether ``targets`` are always observable throughout ``time_range`` given constraints in\",\n \"t2 = Time(\\\"2016-03-30T12:00:00\\\") >>> constraint = TimeConstraint(t1,t2) \\\"\\\"\\\" self.min = min self.max =\",\n \"= self.max mi = 1 if self.min is None else self.min # values\",\n \"<= self.max)) return mask def is_always_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" A\",\n \"(optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. ephemeris : str,\",\n \"'__len__'): constraints = [constraints] is_24hr_table = False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range\",\n \"---------- times : `~astropy.time.Time` Array of times on which to test the constraint.\",\n \"hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey = _make_cache_key(times, 'sun') if aakey not in\",\n \"Moon has set. \\\"\\\"\\\" def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"np.bool_(min_time <= times.datetime.time() <= max_time) # If time boundaries straddle midnight: else: try:\",\n \"column ``'time observable'`` will also be present if the ``time_range`` is given as\",\n \"and 1 min_val : float worst acceptable value (rescales to 0) max_val :\",\n \"illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def\",\n \"= min self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer, targets):\",\n \"observer, target, times=None, times_ingress_egress=None): \\\"\\\"\\\" Determines if the ``target`` is observable at each\",\n \"constraint_arr = np.logical_and.reduce(applied_constraints) months_observable = [] for target, observable in zip(targets, constraint_arr): s\",\n \"(optional) Force the pressure to zero for solar altitude calculations. This avoids errors\",\n \"``vals`` to be a score (between zero and one), where the ``max_val`` goes\",\n \"to apply the constraints. Returns ------- constraint_result : 2D array of float or\",\n \"This method could be sped up a lot by dropping to the trigonometric\",\n \"def compute_constraint(self, times, observer, targets): cached_altaz = _get_altaz(times, observer, targets) secz = cached_altaz['altaz'].secz.value\",\n \"or from observer if self.min is not None: timezone = self.min.tzinfo elif self.max\",\n \"``constraints`` for a particular ``observer``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational\",\n \"self.min is None and self.max is not None: mask = secz <= self.max\",\n \"Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min\",\n \"constraint_arr = np.logical_and.reduce(applied_constraints) return np.all(constraint_arr, axis=1) def is_observable(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):\",\n \"illumination (inclusive). `None` indicates no limit. max : float or `None` (optional) Maximum\",\n \"1] applied_constraints_ing = [constraint(observer, target, times=times_ing, grid_times_targets=True) for constraint in constraints] applied_constraints_egr =\",\n \"associate an acceptable time range with a specific observing block. This can be\",\n \"should also return one, in some cases it should return zero) Returns -------\",\n \"if the ``time_range`` is given as a scalar. It also contains metadata entries\",\n \"= min self.max = max def compute_constraint(self, times, observer, targets): separation = abs(targets.transform_to(Galactic).b)\",\n \"time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer'] = observer tab.meta['constraints'] = constraints\",\n \"mx = self.max mi = 1 if self.min is None else self.min #\",\n \"TIME_RANGE ARE SET? time_range : `~astropy.time.Time` (length = 2) Lower and upper bounds\",\n \"self.min # values below 1 should be disregarded return min_best_rescale(secz, mi, mx, less_than_min=0)\",\n \"'ever observable', 'always observable', 'fraction of time observable'] target_names = [target.name for target\",\n \"moon and target (inclusive). `None` indicates no limit. ephemeris : str, optional Ephemeris\",\n \"supply either a minimum or a maximum time.\\\") if self.min is not None:\",\n \"= PhaseConstraint(binary, min=0.6, max=0.2) \\\"\\\"\\\" self.periodic_event = periodic_event if (min < 0) or\",\n \"1 and worst (35) going to 0. For values outside the range, the\",\n \": `~astropy.units.Quantity` or `None` Maximum altitude of the target (inclusive). `None` indicates no\",\n \"time sequence If ``time_range`` is not specified, defaults to current year (localtime) time_grid_resolution\",\n \", 0.6, 0.2, 0. , 0. ]) \\\"\\\"\\\" rescaled = (vals - max_val)\",\n \"Array of ingress and egress times for ``N`` events, with shape (``N``, 2).\",\n \"altitude of the target (inclusive). `None` indicates no limit. max : `~astropy.units.Quantity` or\",\n \"def __init__(self, periodic_event, min=None, max=None): \\\"\\\"\\\" Parameters ---------- periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass\",\n \"these to find the correct shape shp1, shp2 = times.shape, targets.shape x =\",\n \"-------- Constrain the observations to targets that are observable between 23:50 and 04:08\",\n \"below ``min_val``. (in some cases anything less than ``min_val`` should also return one,\",\n \"the best (1) and worst (2.25). All values outside the range should return\",\n \"Sun's coordinates in an observer # centred frame, so the separation is as-seen\",\n \"None: self.min = -90*u.deg else: self.min = min if max is None: self.max\",\n \"constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure : bool\",\n \"altitude=altitude) finally: if self.force_pressure_zero: observer.pressure = observer_old_pressure else: altitude = observer._altaz_cache[aakey]['altitude'] return altitude\",\n \"of the target (inclusive). `None` indicates no limit. boolean_constraint : bool If True,\",\n \"if self.min is None else self.min # values below 1 should be disregarded\",\n \"string. targkey = (targets,) except BaseException: targkey = (targets.frame.data.lon,) return timekey + targkey\",\n \"max and/or min specified in \\\" \\\"MoonSeparationConstraint.\\\") return mask class LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"Latest time (inclusive). `None` indicates no limit. Examples -------- Constrain the observations to\",\n \"mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times during primary eclipse. \\\"\\\"\\\" def\",\n \"<= t.time() <= max_time for t in times.datetime]) except BaseException: # use np.bool\",\n \"AtNightConstraint(Constraint): \\\"\\\"\\\" Constrain the Sun to be below ``horizon``. \\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self,\",\n \": `~astropy.time.Time` The times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES\",\n \"will be passed as the first argument into `~astroplan.time_grid_from_range`. time_grid_resolution : `~astropy.units.Quantity` (optional)\",\n \"if self.max is not None: max_time = self.max else: max_time = datetime.time(23, 59,\",\n \"acceptable value (rescales to 0) max_val : float best value cared about (rescales\",\n \"min is None: self.min = -90*u.deg else: self.min = min if max is\",\n \"that is what we want. moon_separation = moon.separation(targets) if self.min is None and\",\n \"\\\"astropy.time.Time objects.\\\") if self.max is not None: if not isinstance(self.max, Time): raise TypeError(\\\"Time\",\n \"eclipse. \\\"\\\"\\\" self.eclipsing_system = eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times)\",\n \"those times. \\\"\\\"\\\" if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} # convert times,\",\n \"times), ``'observer'`` (the `~astroplan.Observer` object), and ``'constraints'`` (containing the supplied ``constraints``). \\\"\\\"\\\" if\",\n \"cached_altaz['altaz'].alt if self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max\",\n \"0. For values outside the range, the rescale should return 0 below 35\",\n \"simple numpy arrays of the same shape and # broadcast these to find\",\n \"\\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance between the Sun and\",\n \"target is observable in the time range given the constraints. \\\"\\\"\\\" if not\",\n \"no limit. max : `~datetime.time` Latest local time (inclusive). `None` indicates no limit.\",\n \"(inclusive). `None` indicates no limit. boolean_constraint : bool If True, the constraint is\",\n \"not None: mask = self.min <= separation elif self.min is not None and\",\n \"self.min = min self.max = max if self.min is None and self.max is\",\n \"_get_solar_altitudes(self, times, observer, targets): if not hasattr(observer, '_altaz_cache'): observer._altaz_cache = {} aakey =\",\n \"for all the ``targets`` over the requested ``time_range``, given the constraints in ``constraints_list``\",\n \"the two times in ``time_range`` with grid spacing ``time_resolution`` for ``observer``. Cache the\",\n \"alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those times. \\\"\\\"\\\"\",\n \"zero) Returns ------- array of floats between 0 and 1 inclusive rescaled so\",\n \"None: raise ValueError(\\\"Cannot have a float AirmassConstraint if max is None.\\\") else: mx\",\n \"AirmassConstraint if max is None.\\\") else: mx = self.max mi = 1 if\",\n \"class would be to associate an acceptable time range with a specific observing\",\n \"for a combination of ``targets`` and ``times`` in a cache on an ``observer```\",\n \"`None` (optional) Minimum acceptable separation between moon and target (inclusive). `None` indicates no\",\n \"`~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event times on which\",\n \"for the alt/az computations, (2) 'altaz' contains the corresponding alt/az coordinates at those\",\n \"to apply the constraints targets : sequence of `~astroplan.Target` The targets on which\",\n \"hashable tuple for use as a cache key \\\"\\\"\\\" # make a tuple\",\n \"= cached_altaz['altaz'].secz.value if self.boolean_constraint: if self.min is None and self.max is not None:\",\n \"= SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis] times, targets = observer._preprocess_inputs(times,\",\n \"times, observer, targets): # use get_body rather than get sun here, since #\",\n \"`None` (optional) Maximum acceptable fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return\",\n \"= cached_moon['altaz'].alt moon_down_mask = moon_alt < 0 moon_up_mask = moon_alt >= 0 illumination\",\n \"from astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>>\",\n \"= np.any(constraint_arr, axis=1) always_obs = np.all(constraint_arr, axis=1) frac_obs = np.sum(constraint_arr, axis=1) / constraint_arr.shape[1]\",\n \"def grey(cls, min=0.25, max=0.65, **kwargs): \\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of a\",\n \"and worst (2.25). All values outside the range should return 0. >>> from\",\n \"about (rescales to 1) greater_than_max : 0 or 1 what is returned for\",\n \"\\\"\\\"\\\" Constrain the distance between the Earth's moon and some targets. \\\"\\\"\\\" def\",\n \"Parameters ---------- vals : array-like the values that need to be rescaled to\",\n \"maximum phase must be described on the interval [0, 1). To constrain observations\",\n \"np >>> altitudes = np.array([20, 30, 40, 45, 55, 70]) >>> max_best_rescale(altitudes, 35,\",\n \"------- cache_key : tuple A hashable tuple for use as a cache key\",\n \"times to compute the constraint. WHAT HAPPENS WHEN BOTH TIMES AND TIME_RANGE ARE\",\n \"None: mask = self.min <= separation elif self.min is not None and self.max\",\n \"max_val rescaled[below] = less_than_min rescaled[above] = 0 return rescaled def max_best_rescale(vals, min_val, max_val,\",\n \"tab['time observable'] = tab['fraction of time observable'] * 24*u.hour tab.meta['times'] = times.datetime tab.meta['observer']\",\n \"self.max is not None: mask = self.max >= separation elif self.max is None\",\n \"Parameters ---------- min : `~datetime.time` Earliest local time (inclusive). `None` indicates no limit.\",\n \"= 90*u.deg else: self.max = max self.boolean_constraint = boolean_constraint def compute_constraint(self, times, observer,\",\n \"`None` (optional) Minimum acceptable separation between Sun and target (inclusive). `None` indicates no\",\n \"times in ``time_range`` by checking constraint at linearly-spaced times separated by ``time_resolution``. Default\",\n \"acceptable time range with a specific observing block. This can be useful if\",\n \"Creates a table with information about observability for all the ``targets`` over the\",\n \"the same shape and # broadcast these to find the correct shape shp1,\",\n \"Galactic latitude of target (inclusive). `None` indicates no limit. \\\"\\\"\\\" self.min = min\",\n \"-90*u.deg else: self.min = min if max is None: self.max = 90*u.deg else:\",\n \"get_moon, Galactic, SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks\",\n \"return mask class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within certain time\",\n \"= np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self, periodic_event,\",\n \"or `None` (optional) Minimum acceptable Galactic latitude of target (inclusive). `None` indicates no\",\n \"length as ``targets`` for whether or not each target is ever observable in\",\n \"False if hasattr(time_range, 'isscalar') and time_range.isscalar: time_range = (time_range-12*u.hour, time_range+12*u.hour) is_24hr_table = True\",\n \"- max_val) below = vals < min_val above = vals > max_val rescaled[below]\",\n \"there is potential for huge speedup if the end user # disables gridding\",\n \"None # get timezone from time objects, or from observer if self.min is\",\n \": {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target or list of targets. observer : `~astroplan.Observer` The\",\n \"limits must be specified as \\\" \\\"astropy.time.Time objects.\\\") def compute_constraint(self, times, observer, targets):\",\n \"if self.min is None else self.min max_time = Time(\\\"2120-01-01T00:00:00\\\") if self.max is None\",\n \"__init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.time.Time` Earliest time (inclusive). `None`\",\n \"specific ``observer``, given the supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint`\",\n \"contains the times for the alt/az computations, (2) 'altaz' contains the corresponding alt/az\",\n \"Earliest time (inclusive). `None` indicates no limit. max : `~astropy.time.Time` Latest time (inclusive).\",\n \"\\\"\\\"\\\" initialize a `~astroplan.constraints.MoonIlluminationConstraint` with defaults of no minimum and a maximum of\",\n \"In the current implementation the airmass is approximated by the secant of the\",\n \"---------- eclipsing_system : `~astroplan.periodic.EclipsingSystem` System which must be in primary eclipse. \\\"\\\"\\\" self.eclipsing_system\",\n \"of phases for a periodic event (e.g.~transiting exoplanets, eclipsing binaries). \\\"\\\"\\\" def __init__(self,\",\n \"def __init__(self, min=None, max=None, ephemeris=None): \\\"\\\"\\\" Parameters ---------- min : float or `None`\",\n \"observer who has constraints ``constraints``. force_zero_pressure : bool Forcefully use 0 pressure. Returns\",\n \"a target. In the current implementation the airmass is approximated by the secant\",\n \"and 1.2, for example, you should subtract one from the second number: >>>\",\n \"t in times[observable]]) months_observable.append(s) return months_observable def observability_table(constraints, observer, targets, times=None, time_range=None, time_grid_resolution=0.5*u.hour):\",\n \"cared about (rescales to 1) less_than_min : 0 or 1 what is returned\",\n \"convert times to tuple for hashing aakey = _make_cache_key(times, targets) if aakey not\",\n \"`None` Maximum airmass of the target. `None` indicates no limit. min : float\",\n \"floats between 0 and 1 inclusive rescaled so that ``vals`` equal to ``min_val``\",\n \"------- constraint_result : 2D array of float or bool The constraints, with targets\",\n \"(inclusive). `None` indicates no limit. max : `~datetime.time` Latest local time (inclusive). `None`\",\n \"times : `~astropy.time.Time` Array of times on which to test the constraint. targets\",\n \"observer, targets): separation = abs(targets.transform_to(Galactic).b) if self.min is None and self.max is not\",\n \"self.max is None and self.min is not None: mask = self.min <= solar_separation\",\n \"observer, targets) mask = solar_altitude <= self.max_solar_altitude return mask class GalacticLatitudeConstraint(Constraint): \\\"\\\"\\\" Constrain\",\n \"angle. .. note:: The ``max`` and ``min`` arguments appear in the order (max,\",\n \"use the one set with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default).\",\n \"with spacing ``time_resolution``. This will be passed as the first argument into `~astroplan.time_grid_from_range`.\",\n \"SkyCoord from astropy import table import numpy as np from numpy.lib.stride_tricks import as_strided\",\n \"self.boolean_constraint: lowermask = self.min <= alt uppermask = alt <= self.max return lowermask\",\n \"PhaseConstraint(Constraint): \\\"\\\"\\\" Constrain observations to times in some range of phases for a\",\n \"eclipsing or non-eclipsing binary, or exoplanet system. min : float (optional) Minimum phase\",\n \"acceptable fractional illumination (inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs)\",\n \"class TimeConstraint(Constraint): \\\"\\\"\\\"Constrain the observing time to be within certain time limits. An\",\n \"1) shape coord targets = SkyCoord(np.tile(targets, 1))[:, np.newaxis] else: targets = targets[..., np.newaxis]\",\n \"If ``time_range`` is specified, determine whether constraints are met between test times in\",\n \"= 2) Lower and upper bounds on time sequence. time_grid_resolution : `~astropy.units.quantity` Time-grid\",\n \"times along the second. Otherwise, we rely on broadcasting the shapes together using\",\n \"if targets is not None: # broadcasting times v targets is slow due\",\n \"float worst acceptable value (rescales to 0) max_val : float best value cared\",\n \"month that a target is observable, one set per target. These integers are\",\n \"vals < min_val above = vals > max_val rescaled[below] = 0 rescaled[above] =\",\n \"Calculate next meridian transit for an array of times for ``targets`` and ``observer``.\",\n \"\\\"\\\"\\\" @u.quantity_input(horizon=u.deg) def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True): \\\"\\\"\\\" Parameters ---------- max_solar_altitude : `~astropy.units.Quantity` The\",\n \"supplied ``constraints``. Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer :\",\n \"value cared about (rescales to 1) greater_than_max : 0 or 1 what is\",\n \"of the moon coord # which is GCRS, and that is what we\",\n \"vals : array-like the values that need to be rescaled to be between\",\n \"observer : `~astroplan.Observer` the observaton location from which to apply the constraints targets\",\n \"altitude calculations. This avoids errors in the altitude of the Sun that can\",\n \"\\\"SecondaryEclipseConstraint\\\", \\\"Constraint\\\", \\\"TimeConstraint\\\", \\\"observability_table\\\", \\\"months_observable\\\", \\\"max_best_rescale\\\", \\\"min_best_rescale\\\", \\\"PhaseConstraint\\\", \\\"is_event_observable\\\"] _current_year = time.localtime().tm_year #\",\n \"constraints. If 2D with targets along the first index and times along the\",\n \"= eclipsing_system def compute_constraint(self, times, observer=None, targets=None): mask = self.eclipsing_system.in_secondary_eclipse(times) return mask class\",\n \"(2) 'altaz' contains the corresponding alt/az coordinates at those times and (3) contains\",\n \"Parameters ---------- constraints : list or `~astroplan.constraints.Constraint` Observational constraint(s) observer : `~astroplan.Observer` The\",\n \"= time_grid_from_range(time_range, time_resolution=time_grid_resolution) if is_24hr_table: tab['time observable'] = tab['fraction of time observable'] *\",\n \"min specified in \\\" \\\"GalacticLatitudeConstraint.\\\") return mask class SunSeparationConstraint(Constraint): \\\"\\\"\\\" Constrain the distance\",\n \"observable, one set per target. These integers are 1-based so that January maps\",\n \"for solar altitude calculations. This avoids errors in the altitude of the Sun\",\n \"\\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional) Minimum acceptable Galactic latitude\",\n \"of the Sun that can occur when the Sun is below the horizon\",\n \"= [constraint(observer, target, times=times_egr, grid_times_targets=True) for constraint in constraints] constraint_arr = np.logical_and(np.logical_and.reduce(applied_constraints_ing), np.logical_and.reduce(applied_constraints_egr))\",\n \"max_solar_altitude : `~astropy.units.Quantity` The altitude of the sun below which it is considered\",\n \"LocalTimeConstraint(Constraint): \\\"\\\"\\\" Constrain the observable hours. \\\"\\\"\\\" def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters\",\n \"def __init__(self, min=None, max=None): \\\"\\\"\\\" Parameters ---------- min : `~astropy.units.Quantity` or `None` (optional)\",\n \"same shape and # broadcast these to find the correct shape shp1, shp2\",\n \"We make # to simple numpy arrays of the same shape and #\",\n \"target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times : `~astropy.time.Time` (optional) Array of mid-event\",\n \"observable'``. The column ``'time observable'`` will also be present if the ``time_range`` is\",\n \"(inclusive). `None` indicates no limit. \\\"\\\"\\\" return cls(min, max, **kwargs) @classmethod def bright(cls,\",\n \"if not isinstance(self.min, datetime.time): raise TypeError(\\\"Time limits must be specified as datetime.time objects.\\\")\",\n \"(35) going to 0. For values outside the range, the rescale should return\",\n \"of times on which to test the constraint. targets : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`}\",\n \"when the Sun is below the horizon and the corrections for atmospheric refraction\",\n \"the constraint. observer : `~astroplan.Observer` The observer who has constraints ``constraints``. force_zero_pressure :\",\n \"compute_constraint(self, times, observer, targets): with warnings.catch_warnings(): warnings.simplefilter('ignore') min_time = Time(\\\"1950-01-01T00:00:00\\\") if self.min is\",\n \"@classmethod def twilight_civil(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between civil twilights (-6\",\n \"also return one, in some cases it should return zero) Returns ------- array\",\n \"mask = np.logical_and(times > min_time, times < max_time) return mask class PrimaryEclipseConstraint(Constraint): \\\"\\\"\\\"\",\n \"cls(max_solar_altitude=-6*u.deg, **kwargs) @classmethod def twilight_nautical(cls, **kwargs): \\\"\\\"\\\" Consider nighttime as time between nautical\",\n \"hours. Returns ------- observability_table : `~astropy.table.Table` A Table containing the observability information for\",\n \"time_grid_resolution=0.5*u.hour): \\\"\\\"\\\" Creates a table with information about observability for all the ``targets``\",\n \"with ``astropy.coordinates.solar_system_ephemeris.set`` (which is set to 'builtin' by default). \\\"\\\"\\\" self.min = min\",\n \"self.max)) else: raise ValueError(\\\"No max and/or min specified in \\\" \\\"SunSeparationConstraint.\\\") return mask\",\n \"= ['target name', 'ever observable', 'always observable', 'fraction of time observable'] target_names =\",\n \"LICENSE.rst \\\"\\\"\\\" Specify and constraints to determine which targets are observable for an\",\n \"None else self.min # values below 1 should be disregarded return min_best_rescale(secz, mi,\",\n \"astropy.time import Time >>> subaru = Observer.at_site(\\\"Subaru\\\") >>> t1 = Time(\\\"2016-03-28T12:00:00\\\") >>> t2\"\n]","isConversational":false}}},{"rowIdx":2489,"cells":{"ngram":{"kind":"list like","value":["def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator =","@login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id)","PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return","messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required()","= request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage:","= PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form']","context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm()","'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def","return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] =","= {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context","= tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES,","if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request,","context = {} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST':","tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request):","'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form =","def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method","post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context","@login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if","'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if","created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request,","context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required()","'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return","if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request,","context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if","return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id):","tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags =","= {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page","{} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form =","django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag","context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST,","context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.')","from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import","= PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] =","if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request,","PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] =","backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request):","HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all()","context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST,","from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from","form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html',","@login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if","'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category","= Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories","return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories'","Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except","form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts'))","import render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from","import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import","def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator =","= {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form =","return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags'","context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category =","updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request,","@login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator","= 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def","request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form","= PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid():","Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {}","'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories'","form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid():","deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list","updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request,","Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form =","= Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form","'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return","form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context)","'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request):","= TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid():","{} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form =","= paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context","delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request,","context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form","return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id):","== 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return","def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete()","= 'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES)","context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request):","return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list =","Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http","from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import","render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form","render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories'","delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request,","django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse","{} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context =","form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context)","tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag)","form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context)","# Create your views here. @login_required() def index(request): context = {} context['nav_active'] =","= 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def","= 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active']","tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag","import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from","PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import","'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories'))","@login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id)","import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from","form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html',","= paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html',","form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active']","category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active']","render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories'","posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request):","category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category)","= TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form']","EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def","form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context)","add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if request.method ==","category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context","= paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context","form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html',","TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form","messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required()","categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request,","form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form']","edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] =","form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form']","request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag","== 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.')","form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid():","'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] =","return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] =","= {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form =","Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except","= {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page","{} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category)","= paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts']","context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page')","== 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.')","return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] =","'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags'))","add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if request.method ==","= PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save()","posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] =","paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger:","= 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method","if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request,","return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts'","{} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag)","context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10)","= {} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form","form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context)","context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST,","request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form","10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1)","render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts'","CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form","{} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form =","= CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] =","= Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page)","= {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return","import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your","CategoryForm, TagForm # Create your views here. @login_required() def index(request): context = {}","PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request): context =","paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context =","messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] =","Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form =","'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def","Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form =","import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request): context","from backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def","def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete()","created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request,","== 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return","context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {}","context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if","= form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {}","context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.')","your views here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return","context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if","request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags","form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if","context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required()","= form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {}","views here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request,","post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post","render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form","if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request,","@login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if","'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def","posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request,","@login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id)","except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories","delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request,","django.contrib import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage","messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required()","context = {} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST':","context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context =","form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context)","render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts'","@login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id)","tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages)","import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm,","{} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories'))","render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form","from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post, Category,","form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active']","request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category","context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST,","PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return","= 'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES)","= Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags","category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST':","messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required()","request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.')","= request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage:","PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form","= form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {}","def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if request.method","= categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active']","if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag","= CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save()","= paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories']","def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete()","'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if","paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context)","form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid():","categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages)","page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except","{} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page =","context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form","category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category","= Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context =","context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST':","context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag =","context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context =","return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id):","try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts =","tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST':","return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id):","posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)),","'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return","= Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form","{} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post)","context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page')","return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] =","core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create","= form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {}","context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context =","django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm,","{} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.') return HttpResponseRedirect(reverse('user_panel_tags'))","instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return","'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag","'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category","context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10)","categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)),","render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags'","'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post","request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.')","CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save()","form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html',","HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context","form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active']","form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active']","render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list","= TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save()","paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger:","Create your views here. @login_required() def index(request): context = {} context['nav_active'] = 'index'","'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form =","= 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try:","request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form","paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context)","request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories","TagForm # Create your views here. @login_required() def index(request): context = {} context['nav_active']","Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {}","= tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active']","context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm()","messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers","context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST,","render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags'","Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except","edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] =","request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return","'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method ==","= {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.') return","request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts","context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post =","def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required()","= form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {}","context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category =","context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all()","post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts =","context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {}","Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views here.","request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post","messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] =","paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context)","context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.')","@login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id)","categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request):","= 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method","context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page')","= request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage:","= 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method","paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger:","Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views","post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post)","= category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES,","= 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try:","'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post","messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required()","from django.contrib import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger,","context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post =","return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] =","'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags'","instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return","'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def","'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def","{} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page =","return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id):","'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag","context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form","CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] =","if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category","paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context =","form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active']","if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request,","context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context =","HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all()","context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {}","context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context =","form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories'))","PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save()","= {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return","'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list =","HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context","messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required()","def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if request.method","Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required()","form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if","form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form']","TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save()","updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request,","= CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid():","@login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator","'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories","request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.')","tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)),","categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories =","return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts'","form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if","request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return","login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts","if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request,","10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1)","'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if","HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context","return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] =","paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] =","== 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return","tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] =","context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag =","'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags","'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts'))","= Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context =","{} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page =","'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method ==","def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator =","paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context =","def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post']","= {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page","post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active']","paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] =","created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request,","= paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags']","deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list","'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request):","= Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page)","reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post,","django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models","try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories =","django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render","posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages)","here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html',","except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required()","page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except","EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def","EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def","context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context =","from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import","= {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form =","page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except","10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1)","category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category","EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect","context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {}","paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] =","edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] =","PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,","form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html',","post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST':","def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category']","= Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page)","CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,","context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10)","index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def","if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post","request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return","= paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html',","HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context","if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request,","except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required()","= 'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES)","TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,","from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm #","= post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES,","@login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id)","add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method ==","except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags","post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post","categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] =","'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def","import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from","try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags =","TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] =","except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required()","= posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active']","HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context","= 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try:","form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active']","{} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts'))","@login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context)","= paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context","if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request,","Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags =","= {} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form","HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context","= CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form']","= TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] =","'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form =","HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm","tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag","= form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {}","form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags'))","= Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts","def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag']","PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return","Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories =","'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method ==","context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST,","instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return","return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id):","return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list =","render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms","== 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.')","except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts","form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html',","= paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html',","Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts =","'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts","context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm()","= Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form","= {} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form","tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request,","@login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator"],"string":"[\n \"def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator =\",\n \"@login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id)\",\n \"PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return\",\n \"messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required()\",\n \"= request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage:\",\n \"= PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form']\",\n \"context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm()\",\n \"'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def\",\n \"return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] =\",\n \"= {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context\",\n \"= tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES,\",\n \"if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request,\",\n \"context = {} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST':\",\n \"tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request):\",\n \"'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form =\",\n \"def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method\",\n \"post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context\",\n \"@login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if\",\n \"'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if\",\n \"created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request,\",\n \"context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required()\",\n \"'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return\",\n \"if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request,\",\n \"context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if\",\n \"return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id):\",\n \"tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags =\",\n \"= {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page\",\n \"{} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form =\",\n \"django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag\",\n \"context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST,\",\n \"context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.')\",\n \"from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import\",\n \"= PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] =\",\n \"if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request,\",\n \"PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] =\",\n \"backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request):\",\n \"HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all()\",\n \"context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST,\",\n \"from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from\",\n \"form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html',\",\n \"@login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if\",\n \"'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category\",\n \"= Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories\",\n \"return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories'\",\n \"Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except\",\n \"form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts'))\",\n \"import render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from\",\n \"import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import\",\n \"def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator =\",\n \"= {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form =\",\n \"return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags'\",\n \"context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category =\",\n \"updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request,\",\n \"@login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator\",\n \"= 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def\",\n \"request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form\",\n \"= PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid():\",\n \"Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {}\",\n \"'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories'\",\n \"form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid():\",\n \"deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list\",\n \"updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request,\",\n \"Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form =\",\n \"= Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form\",\n \"'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return\",\n \"form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context)\",\n \"'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request):\",\n \"= TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid():\",\n \"{} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form =\",\n \"= paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context\",\n \"delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request,\",\n \"context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form\",\n \"return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id):\",\n \"== 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return\",\n \"def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete()\",\n \"= 'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES)\",\n \"context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request):\",\n \"return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list =\",\n \"Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http\",\n \"from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import\",\n \"render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts' form\",\n \"render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories'\",\n \"delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request,\",\n \"django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse\",\n \"{} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context =\",\n \"form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context)\",\n \"tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag)\",\n \"form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context)\",\n \"# Create your views here. @login_required() def index(request): context = {} context['nav_active'] =\",\n \"= 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def\",\n \"= 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active']\",\n \"tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag\",\n \"import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from\",\n \"PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import\",\n \"'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories'))\",\n \"@login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id)\",\n \"import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from\",\n \"form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html',\",\n \"= paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html',\",\n \"form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {} context['nav_active']\",\n \"category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active']\",\n \"render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories'\",\n \"posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request):\",\n \"category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category)\",\n \"= TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form']\",\n \"EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def\",\n \"form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context)\",\n \"add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if request.method ==\",\n \"category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context\",\n \"= paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context\",\n \"form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html',\",\n \"TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form\",\n \"messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required()\",\n \"categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request,\",\n \"form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form']\",\n \"edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] =\",\n \"form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form']\",\n \"request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag\",\n \"== 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.')\",\n \"form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid():\",\n \"'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] =\",\n \"return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] =\",\n \"= {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form =\",\n \"Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except\",\n \"= {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page\",\n \"{} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category)\",\n \"= paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts']\",\n \"context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page')\",\n \"== 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.')\",\n \"return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] =\",\n \"'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags'))\",\n \"add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if request.method ==\",\n \"= PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save()\",\n \"posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] =\",\n \"paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger:\",\n \"= 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method\",\n \"if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request,\",\n \"return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active'] = 'posts'\",\n \"{} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag)\",\n \"context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10)\",\n \"= {} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form\",\n \"form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context)\",\n \"context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST,\",\n \"request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form\",\n \"10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1)\",\n \"render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts'\",\n \"CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form\",\n \"{} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form =\",\n \"= CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] =\",\n \"= Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page)\",\n \"= {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return\",\n \"import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your\",\n \"CategoryForm, TagForm # Create your views here. @login_required() def index(request): context = {}\",\n \"PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request): context =\",\n \"paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context =\",\n \"messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] =\",\n \"Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST': form =\",\n \"'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def\",\n \"Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form =\",\n \"import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def index(request): context\",\n \"from backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required() def\",\n \"def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete()\",\n \"created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request,\",\n \"== 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return\",\n \"context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {}\",\n \"context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if\",\n \"= form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context = {}\",\n \"context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.')\",\n \"your views here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return\",\n \"context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if\",\n \"request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags\",\n \"form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if\",\n \"context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required()\",\n \"= form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {}\",\n \"views here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request,\",\n \"post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post\",\n \"render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form\",\n \"if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request,\",\n \"@login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if\",\n \"'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def\",\n \"posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request,\",\n \"@login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id)\",\n \"except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories\",\n \"delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request,\",\n \"django.contrib import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage\",\n \"messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required()\",\n \"context = {} context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST':\",\n \"context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context =\",\n \"form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context)\",\n \"render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts'\",\n \"@login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id)\",\n \"tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages)\",\n \"import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm,\",\n \"{} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories'))\",\n \"render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form\",\n \"from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post, Category,\",\n \"form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active']\",\n \"request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category\",\n \"context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST,\",\n \"PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return\",\n \"= 'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES)\",\n \"= Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags\",\n \"category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method == 'POST':\",\n \"messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required()\",\n \"request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.')\",\n \"= request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage:\",\n \"PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form\",\n \"= form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {}\",\n \"def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm() if request.method\",\n \"= categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active']\",\n \"if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag\",\n \"= CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save()\",\n \"= paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories']\",\n \"def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete()\",\n \"'posts' form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if\",\n \"paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context)\",\n \"form = PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid():\",\n \"categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages)\",\n \"page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except\",\n \"{} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page =\",\n \"context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form\",\n \"category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category\",\n \"= Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context =\",\n \"context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST':\",\n \"context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag =\",\n \"context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context =\",\n \"return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id):\",\n \"try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts =\",\n \"tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST':\",\n \"return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id):\",\n \"posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)),\",\n \"'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return\",\n \"= Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method == 'POST': form\",\n \"{} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post)\",\n \"context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page')\",\n \"return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] =\",\n \"core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create\",\n \"= form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {}\",\n \"context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context =\",\n \"django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm,\",\n \"{} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.') return HttpResponseRedirect(reverse('user_panel_tags'))\",\n \"instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return\",\n \"'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag\",\n \"'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category\",\n \"context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10)\",\n \"categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)),\",\n \"render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags'\",\n \"'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post\",\n \"request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.')\",\n \"CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save()\",\n \"form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html',\",\n \"HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context\",\n \"form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active']\",\n \"form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active']\",\n \"render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list\",\n \"= TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save()\",\n \"paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger:\",\n \"Create your views here. @login_required() def index(request): context = {} context['nav_active'] = 'index'\",\n \"'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form =\",\n \"= 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try:\",\n \"request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form\",\n \"paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context)\",\n \"request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories\",\n \"TagForm # Create your views here. @login_required() def index(request): context = {} context['nav_active']\",\n \"Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {}\",\n \"= tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active']\",\n \"context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm()\",\n \"messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers\",\n \"context['nav_active'] = 'tags' form = TagForm() if request.method == 'POST': form = TagForm(request.POST,\",\n \"render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags'\",\n \"Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except\",\n \"edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] =\",\n \"request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return\",\n \"'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method ==\",\n \"= {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.') return\",\n \"request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts\",\n \"context) @login_required() def delete_post(request, post_id): context = {} context['nav_active'] = 'posts' post =\",\n \"def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required()\",\n \"= form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {}\",\n \"context) @login_required() def delete_category(request, category_id): context = {} context['nav_active'] = 'categories' category =\",\n \"context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all()\",\n \"post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts =\",\n \"context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {}\",\n \"Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views here.\",\n \"request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() messages.success(request, 'Post\",\n \"messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] =\",\n \"paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context)\",\n \"context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) tag.delete() messages.success(request, 'Tag deleted.')\",\n \"@login_required() def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id)\",\n \"categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request):\",\n \"= 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form = CategoryForm(instance=category) if request.method\",\n \"context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page')\",\n \"= request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage:\",\n \"= 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method\",\n \"paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger:\",\n \"Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views\",\n \"post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post)\",\n \"= category form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES,\",\n \"= 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try:\",\n \"'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post\",\n \"messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required()\",\n \"from django.contrib import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger,\",\n \"context) @login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post =\",\n \"return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] =\",\n \"'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags'\",\n \"instance=post) if form.is_valid(): form.save() messages.success(request, 'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return\",\n \"'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def\",\n \"'Post updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def\",\n \"{} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page =\",\n \"return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id):\",\n \"'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag\",\n \"context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form\",\n \"CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] =\",\n \"if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category\",\n \"paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context =\",\n \"form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active']\",\n \"if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request,\",\n \"context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context =\",\n \"HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all()\",\n \"context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {}\",\n \"context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context =\",\n \"form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories'))\",\n \"PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save()\",\n \"= {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return\",\n \"'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list =\",\n \"HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request, post_id): context\",\n \"messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required()\",\n \"def add_post(request): context = {} context['nav_active'] = 'posts' form = PostForm() if request.method\",\n \"Tag from backend.forms import PostForm, CategoryForm, TagForm # Create your views here. @login_required()\",\n \"form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES, instance=post) if\",\n \"form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form']\",\n \"TagForm(instance=tag) if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save()\",\n \"updated.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request,\",\n \"= CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid():\",\n \"@login_required() def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator\",\n \"'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories\",\n \"request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.')\",\n \"tags(request): context = {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)),\",\n \"categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories =\",\n \"return render(request, 'backend/index.html', context) @login_required() def posts(request): context = {} context['nav_active'] = 'posts'\",\n \"form = CategoryForm(instance=category) if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if\",\n \"request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return\",\n \"login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts\",\n \"if request.method == 'POST': form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request,\",\n \"10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1)\",\n \"'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if\",\n \"HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context\",\n \"return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context = {} context['nav_active'] =\",\n \"paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] =\",\n \"== 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return\",\n \"tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context = {} context['nav_active'] =\",\n \"context) @login_required() def delete_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag =\",\n \"'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags\",\n \"'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post created.') return HttpResponseRedirect(reverse('user_panel_posts'))\",\n \"= Category.objects.get(pk=category_id) category.delete() messages.success(request, 'Category deleted.') return HttpResponseRedirect(reverse('user_panel_categories')) @login_required() def tags(request): context =\",\n \"{} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page =\",\n \"'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag form = TagForm(instance=tag) if request.method ==\",\n \"def posts(request): context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator =\",\n \"paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context =\",\n \"def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post']\",\n \"= {} context['nav_active'] = 'tags' tags_list = Tag.objects.all() paginator = Paginator(list(reversed(tags_list)), 10) page\",\n \"post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active']\",\n \"paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] =\",\n \"created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def edit_post(request,\",\n \"= paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags']\",\n \"deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list\",\n \"'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request):\",\n \"= Category.objects.all() paginator = Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page)\",\n \"reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models import Post,\",\n \"django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect from core.models\",\n \"try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except EmptyPage: categories =\",\n \"django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render\",\n \"posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages)\",\n \"here. @login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html',\",\n \"except EmptyPage: categories = paginator.page(paginator.num_pages) context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required()\",\n \"page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories = paginator.page(1) except\",\n \"EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required() def\",\n \"EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def\",\n \"context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context =\",\n \"from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import\",\n \"= {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category form =\",\n \"page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except\",\n \"10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts = paginator.page(1)\",\n \"category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category'] = category\",\n \"EmptyPage from django.core.urlresolvers import reverse from django.shortcuts import render from django.http import HttpResponseRedirect\",\n \"context['categories'] = categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {}\",\n \"paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] =\",\n \"edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) context['post'] =\",\n \"PostForm() if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,\",\n \"form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html',\",\n \"post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST':\",\n \"def edit_category(request, category_id): context = {} context['nav_active'] = 'categories' category = Category.objects.get(pk=category_id) context['category']\",\n \"= Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page)\",\n \"CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,\",\n \"context = {} context['nav_active'] = 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10)\",\n \"index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context) @login_required() def\",\n \"if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Post\",\n \"request.FILES) if form.is_valid(): form.save() messages.success(request, 'Category created.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return\",\n \"= paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html',\",\n \"HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id): context\",\n \"if request.method == 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request,\",\n \"except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts return render(request, 'backend/posts.html', context) @login_required()\",\n \"= 'categories' form = CategoryForm() if request.method == 'POST': form = CategoryForm(request.POST, request.FILES)\",\n \"TagForm() if request.method == 'POST': form = TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request,\",\n \"from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm #\",\n \"= post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST, request.FILES,\",\n \"@login_required() def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id)\",\n \"add_category(request): context = {} context['nav_active'] = 'categories' form = CategoryForm() if request.method ==\",\n \"except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags\",\n \"post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post\",\n \"categories return render(request, 'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] =\",\n \"'Post created.') return HttpResponseRedirect(reverse('user_panel_posts')) context['form'] = form return render(request, 'backend/edit_post.html', context) @login_required() def\",\n \"import messages from django.contrib.auth.decorators import login_required from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage from\",\n \"try: tags = paginator.page(page) except PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags =\",\n \"TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] =\",\n \"except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required()\",\n \"= posts return render(request, 'backend/posts.html', context) @login_required() def add_post(request): context = {} context['nav_active']\",\n \"HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html', context) @login_required() def edit_tag(request, tag_id): context\",\n \"= 'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try:\",\n \"form return render(request, 'backend/edit_post.html', context) @login_required() def delete_post(request, post_id): context = {} context['nav_active']\",\n \"{} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id) post.delete() messages.success(request, 'Post deleted.') return HttpResponseRedirect(reverse('user_panel_posts'))\",\n \"@login_required() def index(request): context = {} context['nav_active'] = 'index' return render(request, 'backend/index.html', context)\",\n \"= paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html', context) @login_required() def add_tag(request): context\",\n \"if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request,\",\n \"Paginator(list(reversed(tags_list)), 10) page = request.GET.get('page') try: tags = paginator.page(page) except PageNotAnInteger: tags =\",\n \"= {} context['nav_active'] = 'categories' form = CategoryForm() if request.method == 'POST': form\",\n \"HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def edit_category(request, category_id): context\",\n \"= CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form']\",\n \"= TagForm(request.POST, request.FILES) if form.is_valid(): form.save() messages.success(request, 'Tag created.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] =\",\n \"'backend/categories.html', context) @login_required() def add_category(request): context = {} context['nav_active'] = 'categories' form =\",\n \"HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms import PostForm, CategoryForm, TagForm\",\n \"tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag'] = tag\",\n \"= form return render(request, 'backend/edit_tag.html', context) @login_required() def delete_tag(request, tag_id): context = {}\",\n \"form = TagForm(request.POST, request.FILES, instance=tag) if form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags'))\",\n \"= Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts\",\n \"def edit_tag(request, tag_id): context = {} context['nav_active'] = 'tags' tag = Tag.objects.get(pk=tag_id) context['tag']\",\n \"PageNotAnInteger: tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return\",\n \"Paginator(list(reversed(categories_list)), 10) page = request.GET.get('page') try: categories = paginator.page(page) except PageNotAnInteger: categories =\",\n \"'posts' post = Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method ==\",\n \"context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form = PostForm(request.POST,\",\n \"instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.') return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return\",\n \"return HttpResponseRedirect(reverse('user_panel_categories')) context['form'] = form return render(request, 'backend/edit_category.html', context) @login_required() def delete_category(request, category_id):\",\n \"return HttpResponseRedirect(reverse('user_panel_posts')) @login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list =\",\n \"render from django.http import HttpResponseRedirect from core.models import Post, Category, Tag from backend.forms\",\n \"== 'POST': form = CategoryForm(request.POST, request.FILES, instance=category) if form.is_valid(): form.save() messages.success(request, 'Category updated.')\",\n \"except PageNotAnInteger: posts = paginator.page(1) except EmptyPage: posts = paginator.page(paginator.num_pages) context['posts'] = posts\",\n \"form.is_valid(): form.save() messages.success(request, 'Tag updated.') return HttpResponseRedirect(reverse('user_panel_tags')) context['form'] = form return render(request, 'backend/edit_tag.html',\",\n \"= paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request, 'backend/tags.html',\",\n \"Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts = paginator.page(page) except PageNotAnInteger: posts =\",\n \"'posts' post_list = Post.objects.all() paginator = Paginator(list(reversed(post_list)), 10) page = request.GET.get('page') try: posts\",\n \"context) @login_required() def add_tag(request): context = {} context['nav_active'] = 'tags' form = TagForm()\",\n \"= Post.objects.get(pk=post_id) context['post'] = post form = PostForm(instance=post) if request.method == 'POST': form\",\n \"= {} context['nav_active'] = 'posts' form = PostForm() if request.method == 'POST': form\",\n \"tags = paginator.page(1) except EmptyPage: tags = paginator.page(paginator.num_pages) context['tags'] = tags return render(request,\",\n \"@login_required() def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator\"\n]","isConversational":false}}},{"rowIdx":2490,"cells":{"ngram":{"kind":"list like","value":["import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from","= _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, )","Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader","IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\":","-> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def","= eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray)","_mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\":","import dataclasses import io import multiprocessing as _mp import uuid import zipfile from","= MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] =","str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]]","def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ):","session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes,","# from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError:",".backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test","def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self,","halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self,","model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn,","{\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name,","def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process,","Test for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]]","srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue]","import Connection from typing import List, Optional, Tuple import numpy from tiktorch import","shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices:","import Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple import","self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown()","None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096,","windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen()","log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp","halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process(",".rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name:","_mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection","ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown:","str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale:","rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on","Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue:","import io import multiprocessing as _mp import uuid import zipfile from concurrent.futures import","model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667","bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn","concurrent.futures import Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple","tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip","__init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model =","rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc","srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) ->","probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv =","_mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, ) proc.start()","= {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res =","import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import","\"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes,","log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process(","tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface","name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, ) proc.start() return proc,","create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return","= uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self) ->","multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy from tiktorch","List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip:","io import multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future","from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import","eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) ->","from typing import List, Optional, Tuple import numpy from tiktorch import log from","resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if","int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) ->","Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None","tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer","as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import","from multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy from","devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets","mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_","mean, \"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes,","def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes,","zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model)","def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset,","bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import","MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession","List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession):","try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except","import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably","float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip))","tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc","base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def","conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: #","log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc","devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource","typing import List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc","info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]]","import multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future from","List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets =","model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str,","def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev}","name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset:",") def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip:","kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, ) proc.start() return proc, _mp_rpc.create_client(IRPCModelSession,","List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe()","except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc =","devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn =","= None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process(","import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo:","dataclasses import io import multiprocessing as _mp import uuid import zipfile from concurrent.futures","Connection from typing import List, Optional, Tuple import numpy from tiktorch import log","from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass","= ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices:","numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_","import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from","TODO: Test for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str,","offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection,","ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self)","return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] =","_run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try:","List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit","https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass #","model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file,","if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def","Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn,","IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str input_axes:","valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class","import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for","eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: #","uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo:","input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]]","import numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import","# TODO: Test for model info name: str input_axes: str output_axes: str valid_shapes:","def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model","= {\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo(","scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn:","import List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import","from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from","zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing import List,","import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from","from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import","mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend","as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def","from concurrent.futures import Future from multiprocessing.connection import Connection from typing import List, Optional,","import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from","class ModelInfo: # TODO: Test for model info name: str input_axes: str output_axes:","res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\":","on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn)","with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker =","# probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv","proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip},","-> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ =","target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, ) proc.start() return","import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str","log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip:","List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str])","self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\":","self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue]","= None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE,","@dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str input_axes: str","Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc =","id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self)","class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as","Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from:","None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process,","List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with","input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev):","int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def","None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker","output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str,","id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale,","ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str],","client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices,","ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file:","multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection","MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None","from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO:","self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor:","_mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base","numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp","forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean,","base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model","scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None:","return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) ->","resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running","self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return","uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing","valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def","res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_]","self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_ def get_model_info(self) -> ModelInfo: return","int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes,","self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown()","Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc","= base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res","get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, )","for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo:","from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info","Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown from","devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue:","-> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {}","log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit =","model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self,","List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown","= self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] =","return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean,","self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return","devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future:","-> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str],","from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as","): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1]))","bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices)","(4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue)","server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, ) proc.start() return proc, _mp_rpc.create_client(IRPCModelSession, client_conn)","Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)","ModelInfo: # TODO: Test for model info name: str input_axes: str output_axes: str","conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None )","= resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows","tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class","return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo,","= _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue,",") -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\",","Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex","as _mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import","Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy","offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices:","import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing import","start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]:","self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res","stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\"mean\": mean, \"stddev\": stddev} return id_ def","stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape],","server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\":","{} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor)","from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass","str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str,","ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip,","pass # probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices)","-> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\":","resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue:","running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc,"],"string":"[\n \"import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from\",\n \"= _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, )\",\n \"Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader\",\n \"IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\":\",\n \"-> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def\",\n \"= eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray)\",\n \"_mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\":\",\n \"import dataclasses import io import multiprocessing as _mp import uuid import zipfile from\",\n \"= MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] =\",\n \"str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]]\",\n \"def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ):\",\n \"session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes,\",\n \"# from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError:\",\n \".backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test\",\n \"def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self,\",\n \"halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self,\",\n \"model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn,\",\n \"{\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name,\",\n \"def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process,\",\n \"Test for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]]\",\n \"srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue]\",\n \"import Connection from typing import List, Optional, Tuple import numpy from tiktorch import\",\n \"shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices:\",\n \"import Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple import\",\n \"self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown()\",\n \"None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096,\",\n \"windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen()\",\n \"log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp\",\n \"halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process(\",\n \".rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name:\",\n \"_mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection\",\n \"ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown:\",\n \"str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale:\",\n \"rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on\",\n \"Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue:\",\n \"import io import multiprocessing as _mp import uuid import zipfile from concurrent.futures import\",\n \"model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667\",\n \"bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn\",\n \"concurrent.futures import Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple\",\n \"tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip\",\n \"__init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model =\",\n \"rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc\",\n \"srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) ->\",\n \"probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv =\",\n \"_mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, ) proc.start()\",\n \"= {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res =\",\n \"import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import\",\n \"\\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes,\",\n \"log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process(\",\n \"tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface\",\n \"name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, ) proc.start() return proc,\",\n \"create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return\",\n \"= uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) ->\",\n \"multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy from tiktorch\",\n \"List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip:\",\n \"io import multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future\",\n \"from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import\",\n \"eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) ->\",\n \"from typing import List, Optional, Tuple import numpy from tiktorch import log from\",\n \"resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if\",\n \"int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) ->\",\n \"Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None\",\n \"tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer\",\n \"as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import\",\n \"from multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy from\",\n \"devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets\",\n \"mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_\",\n \"mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes,\",\n \"def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes,\",\n \"zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model)\",\n \"def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset,\",\n \"bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import\",\n \"MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession\",\n \"List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession):\",\n \"try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except\",\n \"import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably\",\n \"float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip))\",\n \"tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc\",\n \"base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def\",\n \"conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: #\",\n \"log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc\",\n \"devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource\",\n \"typing import List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc\",\n \"info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]]\",\n \"import multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future from\",\n \"List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets =\",\n \"model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str,\",\n \"def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev}\",\n \"name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset:\",\n \") def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip:\",\n \"kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, ) proc.start() return proc, _mp_rpc.create_client(IRPCModelSession,\",\n \"List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe()\",\n \"except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc =\",\n \"devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn =\",\n \"= None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process(\",\n \"import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo:\",\n \"dataclasses import io import multiprocessing as _mp import uuid import zipfile from concurrent.futures\",\n \"Connection from typing import List, Optional, Tuple import numpy from tiktorch import log\",\n \"from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass\",\n \"= ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices:\",\n \"numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_\",\n \"import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from\",\n \"TODO: Test for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str,\",\n \"offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection,\",\n \"ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self)\",\n \"return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] =\",\n \"_run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try:\",\n \"List[str], log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit\",\n \"https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass #\",\n \"model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file,\",\n \"if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def\",\n \"Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn,\",\n \"IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str input_axes:\",\n \"valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class\",\n \"import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for\",\n \"eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: #\",\n \"uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo:\",\n \"input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]]\",\n \"import numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import\",\n \"# TODO: Test for model info name: str input_axes: str output_axes: str valid_shapes:\",\n \"def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model\",\n \"= {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo(\",\n \"scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn:\",\n \"import List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import\",\n \"from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base from\",\n \"zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing import List,\",\n \"import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import MPServer from\",\n \"from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from tiktorch.rpc.mp import\",\n \"mp as _mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend\",\n \"as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def\",\n \"from concurrent.futures import Future from multiprocessing.connection import Connection from typing import List, Optional,\",\n \"import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as _mp_rpc from\",\n \"class ModelInfo: # TODO: Test for model info name: str input_axes: str output_axes:\",\n \"res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\":\",\n \"on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn)\",\n \"with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker =\",\n \"# probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv\",\n \"proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip},\",\n \"-> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ =\",\n \"target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, ) proc.start() return\",\n \"import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str\",\n \"log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip:\",\n \"List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str])\",\n \"self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\":\",\n \"self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue]\",\n \"= None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE,\",\n \"@dataclasses.dataclass class ModelInfo: # TODO: Test for model info name: str input_axes: str\",\n \"Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc =\",\n \"id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self)\",\n \"class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as\",\n \"Connection, model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ): try: # from:\",\n \"None ) -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process,\",\n \"List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with\",\n \"input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev):\",\n \"int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def\",\n \"None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker\",\n \"output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str, int]] scale: List[Tuple[str,\",\n \"id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale,\",\n \"ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str],\",\n \"client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices,\",\n \"ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file:\",\n \"multiprocessing as _mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection\",\n \"MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None\",\n \"from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO:\",\n \"self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor:\",\n \"_mp_rpc from tiktorch.rpc.mp import MPServer from tiktorch.server.reader import eval_model_zip from .backend import base\",\n \"numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp\",\n \"forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean,\",\n \"base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model\",\n \"scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices: List[str]) -> None:\",\n \"return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) ->\",\n \"resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running\",\n \"self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return\",\n \"uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing\",\n \"valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown() def\",\n \"res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_]\",\n \"self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def get_model_info(self) -> ModelInfo: return\",\n \"int]] offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes,\",\n \"self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return Shutdown()\",\n \"Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc\",\n \"= base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor) return res\",\n \"get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, )\",\n \"for model info name: str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo:\",\n \"from .rpc_interface import IRPCModelSession @dataclasses.dataclass class ModelInfo: # TODO: Test for model info\",\n \"Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown from\",\n \"devices) srv = MPServer(session_proc, conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue:\",\n \"-> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {}\",\n \"log_queue: Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit =\",\n \"model_file: self._model = eval_model_zip(model_file, devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self,\",\n \"List, Optional, Tuple import numpy from tiktorch import log from tiktorch.rpc import Shutdown\",\n \"= self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] =\",\n \"return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean,\",\n \"self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo, scale=self._model.scale, offset=self._model.offset, ) def shutdown(self) -> Shutdown: self._worker.shutdown() return\",\n \"devices) self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future:\",\n \"-> Shutdown: self._worker.shutdown() return Shutdown() def _run_model_session_process( conn: Connection, model_zip: bytes, devices: List[str],\",\n \"from tiktorch import log from tiktorch.rpc import Shutdown from tiktorch.rpc import mp as\",\n \"): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1]))\",\n \"bytes, devices: List[str]) -> None: with zipfile.ZipFile(io.BytesIO(model_zip)) as model_file: self._model = eval_model_zip(model_file, devices)\",\n \"(4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue)\",\n \"server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue, \\\"model_zip\\\": model_zip}, ) proc.start() return proc, _mp_rpc.create_client(IRPCModelSession, client_conn)\",\n \"Optional[_mp.Queue] = None ): try: # from: https://github.com/pytorch/pytorch/issues/973#issuecomment-346405667 import resource rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)\",\n \"ModelInfo: # TODO: Test for model info name: str input_axes: str output_axes: str\",\n \"conn) srv.listen() def start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None )\",\n \"= resource.getrlimit(resource.RLIMIT_NOFILE) resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows\",\n \"tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass class\",\n \"return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape], halo=self._model.halo,\",\n \"= _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\": log_queue,\",\n \") -> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\",\",\n \"Future: res = self._worker.forward(input_tensor) return res def create_dataset(self, mean, stddev): id_ = uuid.uuid4().hex\",\n \"as _mp import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import\",\n \"Future from multiprocessing.connection import Connection from typing import List, Optional, Tuple import numpy\",\n \"offset: List[Tuple[str, int]] scale: List[Tuple[str, float]] class ModelSessionProcess(IRPCModelSession): def __init__(self, model_zip: bytes, devices:\",\n \"import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from typing import\",\n \"start_model_session_process( model_zip: bytes, devices: List[str], log_queue: Optional[_mp.Queue] = None ) -> Tuple[_mp.Process, IRPCModelSession]:\",\n \"self._datasets = {} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res\",\n \"stddev): id_ = uuid.uuid4().hex self._datasets[id_] = {\\\"mean\\\": mean, \\\"stddev\\\": stddev} return id_ def\",\n \"stddev} return id_ def get_model_info(self) -> ModelInfo: return ModelInfo( self._model.name, self._model.input_axes, self._model.output_axes, valid_shapes=[self._model.input_shape],\",\n \"server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\": server_conn, \\\"devices\\\": devices, \\\"log_queue\\\":\",\n \"{} self._worker = base.SessionBackend(self._model) def forward(self, input_tensor: numpy.ndarray) -> Future: res = self._worker.forward(input_tensor)\",\n \"from tiktorch.server.reader import eval_model_zip from .backend import base from .rpc_interface import IRPCModelSession @dataclasses.dataclass\",\n \"str input_axes: str output_axes: str valid_shapes: List[List[Tuple[str, int]]] halo: List[Tuple[str, int]] offset: List[Tuple[str,\",\n \"ModuleNotFoundError: pass # probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip,\",\n \"pass # probably running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices)\",\n \"-> Tuple[_mp.Process, IRPCModelSession]: client_conn, server_conn = _mp.Pipe() proc = _mp.Process( target=_run_model_session_process, name=\\\"ModelSessionProcess\\\", kwargs={\\\"conn\\\":\",\n \"resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) except ModuleNotFoundError: pass # probably running on windows if log_queue:\",\n \"running on windows if log_queue: log.configure(log_queue) session_proc = ModelSessionProcess(model_zip, devices) srv = MPServer(session_proc,\"\n]","isConversational":false}}},{"rowIdx":2491,"cells":{"ngram":{"kind":"list like","value":["launch(self, session, event): created = [] entities = event['data']['entities'] for entity in entities:","less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True","must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me","of this event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority","entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not","'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None:","entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif (","elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in","id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None)","try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if","from custom attributes of new entities Result: - 'Copy->Pasted' entities won't have same","if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action',","event): created = [] entities = event['data']['entities'] for entity in entities: try: entity_id","id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new'])","None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity","removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities won't","entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"]","created = [] entities = event['data']['entities'] for entity in entities: try: entity_id =","ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] =","BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent):","if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue def register(session): '''Register","this event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority -","of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source","openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from","session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit()","entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new']","entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict","from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): '''","import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event","have same AvalonID as source entity Priority of this event must be less","event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) ==","openpype.modules.ftrack.lib import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent )","event removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities","than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def","= SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created =","( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes","import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class","SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self,","''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event):","and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY","SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created = []","for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add':","Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as an plugin.'''","entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and","entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity Priority","): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY]","Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity Priority of","session.rollback() continue def register(session): '''Register plugin. Called when used as an plugin.''' DelAvalonIdFromNew(session).register()","= event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None)","created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id","AvalonID as source entity Priority of this event must be less than SyncToAvalon","from openpype.modules.ftrack.lib import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent","and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs =","CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id","entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception:","CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes","= True def launch(self, session, event): created = [] entities = event['data']['entities'] for","1 ignore_me = True def launch(self, session, event): created = [] entities =","- 1 ignore_me = True def launch(self, session, event): created = [] entities","= entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is","ignore_me = True def launch(self, session, event): created = [] entities = event['data']['entities']","not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update'","source entity Priority of this event must be less than SyncToAvalon event '''","import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom","None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and","session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as","cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue",") class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new","same AvalonID as source entity Priority of this event must be less than","as source entity Priority of this event must be less than SyncToAvalon event","entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs","custom attributes of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID","entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action',","priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created","= entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif","def launch(self, session, event): created = [] entities = event['data']['entities'] for entity in","== 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity =","AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities won't have","in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if","= ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue def","in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict =","- 'Copy->Pasted' entities won't have same AvalonID as source entity Priority of this","= session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\"","class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new entities","entities won't have same AvalonID as source entity Priority of this event must","event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1","'Copy->Pasted' entities won't have same AvalonID as source entity Priority of this event","\"\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used","[] entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if","and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity),","entity Priority of this event must be less than SyncToAvalon event ''' priority","is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) ==","in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id )","session, event): created = [] entities = event['data']['entities'] for entity in entities: try:","ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue def register(session):","( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created","if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None","None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old']","self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except","== 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is","new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity","SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of","openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This","created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]:","id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in","DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new entities Result:","This event removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted'","be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me =","entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ):","event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session,","= [] entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId']","''' This event removes AvalonId from custom attributes of new entities Result: -","Priority of this event must be less than SyncToAvalon event ''' priority =",") cust_attrs = ftrack_entity[\"custom_attributes\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback()","from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId","won't have same AvalonID as source entity Priority of this event must be","attributes of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as","'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get(","True def launch(self, session, event): created = [] entities = event['data']['entities'] for entity","cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called","except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as an","is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys']","= \"\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when","entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id']","None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and","cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \"\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin."],"string":"[\n \"launch(self, session, event): created = [] entities = event['data']['entities'] for entity in entities:\",\n \"less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True\",\n \"must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me\",\n \"of this event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority\",\n \"entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not\",\n \"'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None:\",\n \"entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif (\",\n \"elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in\",\n \"id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None)\",\n \"try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if\",\n \"from custom attributes of new entities Result: - 'Copy->Pasted' entities won't have same\",\n \"if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action',\",\n \"event): created = [] entities = event['data']['entities'] for entity in entities: try: entity_id\",\n \"id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new'])\",\n \"None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity\",\n \"removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities won't\",\n \"entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"]\",\n \"created = [] entities = event['data']['entities'] for entity in entities: try: entity_id =\",\n \"ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] =\",\n \"BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent):\",\n \"if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue def register(session): '''Register\",\n \"this event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority -\",\n \"of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source\",\n \"openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from\",\n \"session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit()\",\n \"entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new']\",\n \"entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict\",\n \"from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): '''\",\n \"import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event\",\n \"have same AvalonID as source entity Priority of this event must be less\",\n \"event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) ==\",\n \"openpype.modules.ftrack.lib import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent )\",\n \"event removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities\",\n \"than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def\",\n \"= SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created =\",\n \"( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes\",\n \"import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class\",\n \"SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self,\",\n \"''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event):\",\n \"and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY\",\n \"SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created = []\",\n \"for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add':\",\n \"Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as an plugin.'''\",\n \"entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and\",\n \"entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity Priority\",\n \"): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY]\",\n \"Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity Priority of\",\n \"session.rollback() continue def register(session): '''Register plugin. Called when used as an plugin.''' DelAvalonIdFromNew(session).register()\",\n \"= event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action', None)\",\n \"created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id\",\n \"AvalonID as source entity Priority of this event must be less than SyncToAvalon\",\n \"from openpype.modules.ftrack.lib import BaseEvent from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent\",\n \"and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs =\",\n \"CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id\",\n \"entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception:\",\n \"CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes\",\n \"= True def launch(self, session, event): created = [] entities = event['data']['entities'] for\",\n \"1 ignore_me = True def launch(self, session, event): created = [] entities =\",\n \"- 1 ignore_me = True def launch(self, session, event): created = [] entities\",\n \"= entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is\",\n \"ignore_me = True def launch(self, session, event): created = [] entities = event['data']['entities']\",\n \"not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update'\",\n \"source entity Priority of this event must be less than SyncToAvalon event '''\",\n \"import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom\",\n \"None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and\",\n \"session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as\",\n \"cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue\",\n \") class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new\",\n \"same AvalonID as source entity Priority of this event must be less than\",\n \"as source entity Priority of this event must be less than SyncToAvalon event\",\n \"entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs\",\n \"custom attributes of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID\",\n \"entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if entity.get('action',\",\n \"priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session, event): created\",\n \"= entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is None: created.append(id_dict['new']) elif\",\n \"def launch(self, session, event): created = [] entities = event['data']['entities'] for entity in\",\n \"== 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity =\",\n \"AvalonId from custom attributes of new entities Result: - 'Copy->Pasted' entities won't have\",\n \"in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if\",\n \"= ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue def\",\n \"in entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict =\",\n \"- 'Copy->Pasted' entities won't have same AvalonID as source entity Priority of this\",\n \"= session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\"\",\n \"class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new entities\",\n \"entities won't have same AvalonID as source entity Priority of this event must\",\n \"event must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1\",\n \"'Copy->Pasted' entities won't have same AvalonID as source entity Priority of this event\",\n \"\\\"\\\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used\",\n \"[] entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId'] if\",\n \"and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity),\",\n \"entity Priority of this event must be less than SyncToAvalon event ''' priority\",\n \"is not None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) ==\",\n \"in entity['keys'] and entity_id in created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id )\",\n \"session, event): created = [] entities = event['data']['entities'] for entity in entities: try:\",\n \"ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue def register(session):\",\n \"( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created\",\n \"if entity.get('action', None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None\",\n \"None) == 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old']\",\n \"self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except\",\n \"== 'add': id_dict = entity['changes']['id'] if id_dict['new'] is not None and id_dict['old'] is\",\n \"new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as source entity\",\n \"SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of\",\n \"openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This\",\n \"created ): ftrack_entity = session.get( self._get_entity_type(entity), entity_id ) cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]:\",\n \"id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in\",\n \"DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId from custom attributes of new entities Result:\",\n \"This event removes AvalonId from custom attributes of new entities Result: - 'Copy->Pasted'\",\n \"be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me =\",\n \"entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ):\",\n \"event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True def launch(self, session,\",\n \"= [] entities = event['data']['entities'] for entity in entities: try: entity_id = entity['entityId']\",\n \"''' This event removes AvalonId from custom attributes of new entities Result: -\",\n \"Priority of this event must be less than SyncToAvalon event ''' priority =\",\n \") cust_attrs = ftrack_entity[\\\"custom_attributes\\\"] if cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback()\",\n \"from openpype.modules.ftrack.event_handlers_server.event_sync_to_avalon import ( SyncToAvalonEvent ) class DelAvalonIdFromNew(BaseEvent): ''' This event removes AvalonId\",\n \"won't have same AvalonID as source entity Priority of this event must be\",\n \"attributes of new entities Result: - 'Copy->Pasted' entities won't have same AvalonID as\",\n \"'update' and CUST_ATTR_ID_KEY in entity['keys'] and entity_id in created ): ftrack_entity = session.get(\",\n \"True def launch(self, session, event): created = [] entities = event['data']['entities'] for entity\",\n \"cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called\",\n \"except Exception: session.rollback() continue def register(session): '''Register plugin. Called when used as an\",\n \"is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and CUST_ATTR_ID_KEY in entity['keys']\",\n \"= \\\"\\\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin. Called when\",\n \"entities: try: entity_id = entity['entityId'] if entity.get('action', None) == 'add': id_dict = entity['changes']['id']\",\n \"None and id_dict['old'] is None: created.append(id_dict['new']) elif ( entity.get('action', None) == 'update' and\",\n \"cust_attrs[CUST_ATTR_ID_KEY]: cust_attrs[CUST_ATTR_ID_KEY] = \\\"\\\" session.commit() except Exception: session.rollback() continue def register(session): '''Register plugin.\"\n]","isConversational":false}}},{"rowIdx":2492,"cells":{"ngram":{"kind":"list like","value":["tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase):","unittest import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission","from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(),","def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def","workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None,","from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow","self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self): self.assertEqual(self.workflow.name,","import unittest import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import","settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self):","as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def","= workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self): self.assertEqual(self.workflow.name, \"IngestAcceptedSubmission\")","tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow =","TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None )","import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None,","import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class","FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock,","setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self):","workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None,","class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None","import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission("],"string":"[\n \"tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase):\",\n \"unittest import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission\",\n \"from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(),\",\n \"def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def\",\n \"workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None,\",\n \"from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow\",\n \"self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self): self.assertEqual(self.workflow.name,\",\n \"import unittest import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import\",\n \"settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self):\",\n \"as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def\",\n \"= workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self): self.assertEqual(self.workflow.name, \\\"IngestAcceptedSubmission\\\")\",\n \"tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow =\",\n \"TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None )\",\n \"import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None,\",\n \"import tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class\",\n \"FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock,\",\n \"setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None ) def test_init(self):\",\n \"workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None,\",\n \"class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission( settings_mock, FakeLogger(), None, None, None, None\",\n \"import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase): def setUp(self): self.workflow = workflow_IngestAcceptedSubmission(\"\n]","isConversational":false}}},{"rowIdx":2493,"cells":{"ngram":{"kind":"list like","value":["vumi_api def token(request, token): # We only need the redis manager here, but","the redis manager here, but it's saner to get a whole # vumi_api","we need to be if not user_id or request.user.id == user_id: path, _,","being forwarded so the view handling the `redirect_to` # can lookup the token","but it's saner to get a whole # vumi_api and not worry about","size of the user_token # to the token being forwarded so the view","token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name =","or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) #","whole # vumi_api and not worry about all the setup magic. api =","not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token']","not worry about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token)","# vumi_api and not worry about all the setup magic. api = vumi_api()","= int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and","user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token","login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): #","# can lookup the token and verify the system token. params.update({'token': '%s-%s%s' %","manager here, but it's saner to get a whole # vumi_api and not","# logged in or is logged in with a wrong account. if request.user.is_authenticated():","'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token':","from urllib import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views","api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id =","params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message) return","to # where we need to be if not user_id or request.user.id ==","redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api","token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to']","for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), })))","raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs =","params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If","= request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404","api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args","# since the token can be custom we prepend the size of the","message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message) return redirect(return_to)","got here then we need authentication and the user's either not # logged","request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since","the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise","import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib","redirect to # where we need to be if not user_id or request.user.id","go.base.utils import vumi_api def token(request, token): # We only need the redis manager","and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s'","callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level","can be custom we prepend the size of the user_token # to the","params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level']","from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages","only need the redis manager here, but it's saner to get a whole","qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom","(reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api","logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for","user_id then redirect to # where we need to be if not user_id","if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'),","from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from","from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We","'%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we","def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not","= urlparse.parse_qs(qs) # since the token can be custom we prepend the size","request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name","= token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to =","params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name)","of the user_token # to the token being forwarded so the view handling","can lookup the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token),","the token can be custom we prepend the size of the user_token #","If we're authorized and we're the same user_id then redirect to # where","the `redirect_to` # can lookup the token and verify the system token. params.update({'token':","be if not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?')","with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.')","message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level,","logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required","import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import","= params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs)","token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data:","account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' %","import logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import","django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators","messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string","# If we're authorized and we're the same user_id then redirect to #","django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils","then redirect to # where we need to be if not user_id or","view handling the `redirect_to` # can lookup the token and verify the system","then we need authentication and the user's either not # logged in or","reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api","django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils","import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token):","here, but it's saner to get a whole # vumi_api and not worry","from go.base.utils import vumi_api def token(request, token): # We only need the redis","token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] #","urlencode(params))) # If we got here then we need authentication and the user's","token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs","token_data['system_token'] # If we're authorized and we're the same user_id then redirect to","we got here then we need authentication and the user's either not #","from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from","saner to get a whole # vumi_api and not worry about all the","so the view handling the `redirect_to` # can lookup the token and verify","path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can","load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only need the","a whole # vumi_api and not worry about all the setup magic. api","= vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id'])","callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message","prepend the size of the user_token # to the token being forwarded so","logged in or is logged in with a wrong account. if request.user.is_authenticated(): logout(request)","magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id","authorized and we're the same user_id then redirect to # where we need","urlparse.parse_qs(qs) # since the token can be custom we prepend the size of","kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data","setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404","params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to","logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next':","from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse from","if not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params","reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token')","we're the same user_id then redirect to # where we need to be","Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're","vumi_api and not worry about all the setup magic. api = vumi_api() token_data","user's either not # logged in or is logged in with a wrong","all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data:","urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from","params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message']","api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token","we're authorized and we're the same user_id then redirect to # where we","system_token = token_data['system_token'] # If we're authorized and we're the same user_id then","import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers","token being forwarded so the view handling the `redirect_to` # can lookup the","messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token',","% (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api =","need to be if not user_id or request.user.id == user_id: path, _, qs","redis manager here, but it's saner to get a whole # vumi_api and","token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data =","If we got here then we need authentication and the user's either not","token can be custom we prepend the size of the user_token # to","lookup the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token,","system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params)))","import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout","request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params","token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) #","= token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the same","since the token can be custom we prepend the size of the user_token","== user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the","worry about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if","return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request):","}))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token)","and we're the same user_id then redirect to # where we need to","= token_data['system_token'] # If we're authorized and we're the same user_id then redirect","api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise","request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({","and the user's either not # logged in or is logged in with","@login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if","forwarded so the view handling the `redirect_to` # can lookup the token and","(path, urlencode(params))) # If we got here then we need authentication and the","about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not","token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the same user_id","wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s'","params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request,","the user_token # to the token being forwarded so the view handling the","need the redis manager here, but it's saner to get a whole #","or is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong","redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the","it's saner to get a whole # vumi_api and not worry about all","get a whole # vumi_api and not worry about all the setup magic.","django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request,","return redirect('%s?%s' % (path, urlencode(params))) # If we got here then we need","account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}),","token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return","if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token =","either not # logged in or is logged in with a wrong account.","if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args =","import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import","= params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level =","where we need to be if not user_id or request.user.id == user_id: path,","Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs']","params = urlparse.parse_qs(qs) # since the token can be custom we prepend the","token): # We only need the redis manager here, but it's saner to","# where we need to be if not user_id or request.user.id == user_id:","from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def","token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to =","system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here then we","user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized","import vumi_api def token(request, token): # We only need the redis manager here,","to get a whole # vumi_api and not worry about all the setup","import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only need","the user's either not # logged in or is logged in with a","not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args']","redirect('%s?%s' % (path, urlencode(params))) # If we got here then we need authentication","urllib import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import","= redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom we","here then we need authentication and the user's either not # logged in","be custom we prepend the size of the user_token # to the token","redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom we prepend","% (path, urlencode(params))) # If we got here then we need authentication and","% (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got","the view handling the `redirect_to` # can lookup the token and verify the","in or is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request,","the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path,","need authentication and the user's either not # logged in or is logged","= params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message =","return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args,","`redirect_to` # can lookup the token and verify the system token. params.update({'token': '%s-%s%s'","to be if not user_id or request.user.id == user_id: path, _, qs =","callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback","user_token # to the token being forwarded so the view handling the `redirect_to`","# If we got here then we need authentication and the user's either","'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token =","token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def","= params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback =","we need authentication and the user's either not # logged in or is","def token(request, token): # We only need the redis manager here, but it's","= params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message)","not # logged in or is logged in with a wrong account. if","authentication and the user's either not # logged in or is logged in","= api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to']","token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here then","vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to","custom we prepend the size of the user_token # to the token being","and not worry about all the setup magic. api = vumi_api() token_data =","a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return","_, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be","# to the token being forwarded so the view handling the `redirect_to` #","verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' %","= api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name']","token(request, token): # We only need the redis manager here, but it's saner","this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required","token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params =","# We only need the redis manager here, but it's saner to get","we prepend the size of the user_token # to the token being forwarded","Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import","vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only","not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params =","the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)})","the same user_id then redirect to # where we need to be if","redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse","(len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here","raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If","django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from","urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import","urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token","int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're","is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account","the size of the user_token # to the token being forwarded so the","in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this","handling the `redirect_to` # can lookup the token and verify the system token.","to the token being forwarded so the view handling the `redirect_to` # can","the token being forwarded so the view handling the `redirect_to` # can lookup","same user_id then redirect to # where we need to be if not","= request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params']","We only need the redis manager here, but it's saner to get a","user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs)"],"string":"[\n \"vumi_api def token(request, token): # We only need the redis manager here, but\",\n \"the redis manager here, but it's saner to get a whole # vumi_api\",\n \"we need to be if not user_id or request.user.id == user_id: path, _,\",\n \"being forwarded so the view handling the `redirect_to` # can lookup the token\",\n \"but it's saner to get a whole # vumi_api and not worry about\",\n \"size of the user_token # to the token being forwarded so the view\",\n \"token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name =\",\n \"or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) #\",\n \"whole # vumi_api and not worry about all the setup magic. api =\",\n \"not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token']\",\n \"not worry about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token)\",\n \"# vumi_api and not worry about all the setup magic. api = vumi_api()\",\n \"= int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and\",\n \"user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token\",\n \"login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): #\",\n \"# can lookup the token and verify the system token. params.update({'token': '%s-%s%s' %\",\n \"manager here, but it's saner to get a whole # vumi_api and not\",\n \"# logged in or is logged in with a wrong account. if request.user.is_authenticated():\",\n \"'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token':\",\n \"from urllib import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views\",\n \"api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id =\",\n \"params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message) return\",\n \"to # where we need to be if not user_id or request.user.id ==\",\n \"redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api\",\n \"token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to']\",\n \"for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), })))\",\n \"raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs =\",\n \"params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If\",\n \"= request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404\",\n \"api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args\",\n \"# since the token can be custom we prepend the size of the\",\n \"message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message) return redirect(return_to)\",\n \"got here then we need authentication and the user's either not # logged\",\n \"request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since\",\n \"the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise\",\n \"import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib\",\n \"redirect to # where we need to be if not user_id or request.user.id\",\n \"go.base.utils import vumi_api def token(request, token): # We only need the redis manager\",\n \"and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s'\",\n \"callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level\",\n \"can be custom we prepend the size of the user_token # to the\",\n \"params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level']\",\n \"from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages\",\n \"only need the redis manager here, but it's saner to get a whole\",\n \"qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom\",\n \"(reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api\",\n \"logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for\",\n \"user_id then redirect to # where we need to be if not user_id\",\n \"if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'),\",\n \"from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from\",\n \"from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We\",\n \"'%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we\",\n \"def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not\",\n \"= urlparse.parse_qs(qs) # since the token can be custom we prepend the size\",\n \"request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name\",\n \"= token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to =\",\n \"params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name)\",\n \"of the user_token # to the token being forwarded so the view handling\",\n \"can lookup the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token),\",\n \"the token can be custom we prepend the size of the user_token #\",\n \"If we're authorized and we're the same user_id then redirect to # where\",\n \"the `redirect_to` # can lookup the token and verify the system token. params.update({'token':\",\n \"be if not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?')\",\n \"with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.')\",\n \"message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level,\",\n \"logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required\",\n \"import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import\",\n \"= params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs)\",\n \"token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data:\",\n \"account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' %\",\n \"import logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import\",\n \"django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators\",\n \"messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string\",\n \"# If we're authorized and we're the same user_id then redirect to #\",\n \"django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils\",\n \"then redirect to # where we need to be if not user_id or\",\n \"view handling the `redirect_to` # can lookup the token and verify the system\",\n \"then we need authentication and the user's either not # logged in or\",\n \"reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api\",\n \"django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from vumi.utils\",\n \"import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token):\",\n \"here, but it's saner to get a whole # vumi_api and not worry\",\n \"from go.base.utils import vumi_api def token(request, token): # We only need the redis\",\n \"token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] #\",\n \"urlencode(params))) # If we got here then we need authentication and the user's\",\n \"token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs\",\n \"token_data['system_token'] # If we're authorized and we're the same user_id then redirect to\",\n \"we got here then we need authentication and the user's either not #\",\n \"from django.contrib import messages from django.core.urlresolvers import reverse from django.contrib.auth.decorators import login_required from\",\n \"saner to get a whole # vumi_api and not worry about all the\",\n \"so the view handling the `redirect_to` # can lookup the token and verify\",\n \"path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can\",\n \"load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only need the\",\n \"a whole # vumi_api and not worry about all the setup magic. api\",\n \"= vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id'])\",\n \"callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message\",\n \"prepend the size of the user_token # to the token being forwarded so\",\n \"logged in or is logged in with a wrong account. if request.user.is_authenticated(): logout(request)\",\n \"magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id\",\n \"authorized and we're the same user_id then redirect to # where we need\",\n \"urlparse.parse_qs(qs) # since the token can be custom we prepend the size of\",\n \"kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data\",\n \"setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404\",\n \"params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to\",\n \"logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next':\",\n \"from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse from\",\n \"if not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params\",\n \"reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token')\",\n \"we're the same user_id then redirect to # where we need to be\",\n \"Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're\",\n \"vumi_api and not worry about all the setup magic. api = vumi_api() token_data\",\n \"user's either not # logged in or is logged in with a wrong\",\n \"all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not token_data:\",\n \"urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from\",\n \"params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message']\",\n \"api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token\",\n \"we're authorized and we're the same user_id then redirect to # where we\",\n \"system_token = token_data['system_token'] # If we're authorized and we're the same user_id then\",\n \"import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers\",\n \"token being forwarded so the view handling the `redirect_to` # can lookup the\",\n \"messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token',\",\n \"% (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api =\",\n \"need to be if not user_id or request.user.id == user_id: path, _, qs\",\n \"redis manager here, but it's saner to get a whole # vumi_api and\",\n \"token}), }))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data =\",\n \"If we got here then we need authentication and the user's either not\",\n \"token can be custom we prepend the size of the user_token # to\",\n \"lookup the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token,\",\n \"system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params)))\",\n \"import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout\",\n \"request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params\",\n \"token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) #\",\n \"= token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the same\",\n \"since the token can be custom we prepend the size of the user_token\",\n \"== user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the\",\n \"worry about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if\",\n \"return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request):\",\n \"}))) @login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token)\",\n \"and we're the same user_id then redirect to # where we need to\",\n \"= token_data['system_token'] # If we're authorized and we're the same user_id then redirect\",\n \"api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise\",\n \"request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({\",\n \"and the user's either not # logged in or is logged in with\",\n \"@login_required def token_task(request): api = request.user_api.api token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if\",\n \"forwarded so the view handling the `redirect_to` # can lookup the token and\",\n \"(path, urlencode(params))) # If we got here then we need authentication and the\",\n \"about all the setup magic. api = vumi_api() token_data = api.token_manager.get(token) if not\",\n \"token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the same user_id\",\n \"wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return redirect('%s?%s'\",\n \"params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request,\",\n \"the user_token # to the token being forwarded so the view handling the\",\n \"need the redis manager here, but it's saner to get a whole #\",\n \"or is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong\",\n \"redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're the\",\n \"it's saner to get a whole # vumi_api and not worry about all\",\n \"get a whole # vumi_api and not worry about all the setup magic.\",\n \"django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request,\",\n \"return redirect('%s?%s' % (path, urlencode(params))) # If we got here then we need\",\n \"account for this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}),\",\n \"token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return\",\n \"if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token =\",\n \"either not # logged in or is logged in with a wrong account.\",\n \"if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args =\",\n \"import reverse from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import\",\n \"= params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level =\",\n \"where we need to be if not user_id or request.user.id == user_id: path,\",\n \"Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs']\",\n \"params = urlparse.parse_qs(qs) # since the token can be custom we prepend the\",\n \"token): # We only need the redis manager here, but it's saner to\",\n \"# where we need to be if not user_id or request.user.id == user_id:\",\n \"from django.contrib.auth.decorators import login_required from vumi.utils import load_class_by_string from go.base.utils import vumi_api def\",\n \"token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to =\",\n \"system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here then we\",\n \"user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized\",\n \"import vumi_api def token(request, token): # We only need the redis manager here,\",\n \"to get a whole # vumi_api and not worry about all the setup\",\n \"import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only need\",\n \"the user's either not # logged in or is logged in with a\",\n \"not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name'] callback_args = params['callback_args']\",\n \"redirect('%s?%s' % (path, urlencode(params))) # If we got here then we need authentication\",\n \"urllib import urlencode import urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import\",\n \"= redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom we\",\n \"here then we need authentication and the user's either not # logged in\",\n \"be custom we prepend the size of the user_token # to the token\",\n \"redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be custom we prepend\",\n \"% (path, urlencode(params))) # If we got here then we need authentication and\",\n \"% (len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got\",\n \"the view handling the `redirect_to` # can lookup the token and verify the\",\n \"in or is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request,\",\n \"the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' % (path,\",\n \"need authentication and the user's either not # logged in or is logged\",\n \"= params['callback_name'] callback_args = params['callback_args'] callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message =\",\n \"return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args,\",\n \"`redirect_to` # can lookup the token and verify the system token. params.update({'token': '%s-%s%s'\",\n \"to be if not user_id or request.user.id == user_id: path, _, qs =\",\n \"callback_kwargs = params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback\",\n \"user_token # to the token being forwarded so the view handling the `redirect_to`\",\n \"# If we got here then we need authentication and the user's either\",\n \"'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token =\",\n \"token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def\",\n \"= params['callback_kwargs'] return_to = params['return_to'] message = params['message'] message_level = params['message_level'] callback =\",\n \"we need authentication and the user's either not # logged in or is\",\n \"def token(request, token): # We only need the redis manager here, but it's\",\n \"= params['message'] message_level = params['message_level'] callback = load_class_by_string(callback_name) callback(*callback_args, **callback_kwargs) messages.add_message(request, message_level, message)\",\n \"not # logged in or is logged in with a wrong account. if\",\n \"authentication and the user's either not # logged in or is logged in\",\n \"= api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to']\",\n \"token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here then\",\n \"vumi_api() token_data = api.token_manager.get(token) if not token_data: raise Http404 user_id = int(token_data['user_id']) redirect_to\",\n \"custom we prepend the size of the user_token # to the token being\",\n \"and not worry about all the setup magic. api = vumi_api() token_data =\",\n \"a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this token.') return\",\n \"_, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs) # since the token can be\",\n \"# to the token being forwarded so the view handling the `redirect_to` #\",\n \"verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)}) return redirect('%s?%s' %\",\n \"= api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params'] callback_name = params['callback_name']\",\n \"token(request, token): # We only need the redis manager here, but it's saner\",\n \"this token.') return redirect('%s?%s' % (reverse('auth_login'), urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required\",\n \"token = request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params =\",\n \"# We only need the redis manager here, but it's saner to get\",\n \"we prepend the size of the user_token # to the token being forwarded\",\n \"Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import\",\n \"vumi.utils import load_class_by_string from go.base.utils import vumi_api def token(request, token): # We only\",\n \"not user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params =\",\n \"the token and verify the system token. params.update({'token': '%s-%s%s' % (len(token), token, system_token)})\",\n \"the same user_id then redirect to # where we need to be if\",\n \"redirect from django.contrib.auth.views import logout from django.contrib import messages from django.core.urlresolvers import reverse\",\n \"(len(token), token, system_token)}) return redirect('%s?%s' % (path, urlencode(params))) # If we got here\",\n \"raise Http404 user_id = int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If\",\n \"django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import messages from\",\n \"urlparse from django.shortcuts import Http404, redirect from django.contrib.auth.views import logout from django.contrib import\",\n \"urlencode({ 'next': reverse('token', kwargs={'token': token}), }))) @login_required def token_task(request): api = request.user_api.api token\",\n \"int(token_data['user_id']) redirect_to = token_data['redirect_to'] system_token = token_data['system_token'] # If we're authorized and we're\",\n \"is logged in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account\",\n \"the size of the user_token # to the token being forwarded so the\",\n \"in with a wrong account. if request.user.is_authenticated(): logout(request) messages.info(request, 'Wrong account for this\",\n \"handling the `redirect_to` # can lookup the token and verify the system token.\",\n \"to the token being forwarded so the view handling the `redirect_to` # can\",\n \"the token being forwarded so the view handling the `redirect_to` # can lookup\",\n \"same user_id then redirect to # where we need to be if not\",\n \"= request.GET.get('token') token_data = api.token_manager.verify_get(token) if not token_data: raise Http404 params = token_data['extra_params']\",\n \"We only need the redis manager here, but it's saner to get a\",\n \"user_id or request.user.id == user_id: path, _, qs = redirect_to.partition('?') params = urlparse.parse_qs(qs)\"\n]","isConversational":false}}},{"rowIdx":2494,"cells":{"ngram":{"kind":"list like","value":["force_unicode(text) f.is_safe = True out = text try: out = f(text) except TypogrifyError,","template.Library() def make_safe(f): \"\"\" A function wrapper to make typogrify play nice with","make typogrify play nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text","f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe","import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps","unicode support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out","\"\"\" A function wrapper to make typogrify play nice with django's unicode support.","typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings from django","play nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text)","django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register =","typogrify.filters import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import","True out = text try: out = f(text) except TypogrifyError, e: if settings.DEBUG:","@wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out = text try:","from django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register","django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \"\"\"","def wrapper(text): text = force_unicode(text) f.is_safe = True out = text try: out","out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return","caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf","f.is_safe = True out = text try: out = f(text) except TypogrifyError, e:","make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify)) register.filter('widont', make_safe(widont))","A function wrapper to make typogrify play nice with django's unicode support. \"\"\"","return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify',","mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants',","from django.conf import settings from django import template from django.utils.safestring import mark_safe from","TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True","text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return","function wrapper to make typogrify play nice with django's unicode support. \"\"\" @wraps(f)","text = force_unicode(text) f.is_safe = True out = text try: out = f(text)","make_safe(f): \"\"\" A function wrapper to make typogrify play nice with django's unicode","True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase))","\"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out = text","wrapper to make typogrify play nice with django's unicode support. \"\"\" @wraps(f) def","mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \"\"\" A function","smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings","functools import wraps from django.conf import settings from django import template from django.utils.safestring","to make typogrify play nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text):","template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def","support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out =","= True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase',","titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings from","register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify)) register.filter('widont',","e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return","except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe =","with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe =","= template.Library() def make_safe(f): \"\"\" A function wrapper to make typogrify play nice","def make_safe(f): \"\"\" A function wrapper to make typogrify play nice with django's","text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes',","= text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e","return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes))","try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text","= True out = text try: out = f(text) except TypogrifyError, e: if","import force_unicode register = template.Library() def make_safe(f): \"\"\" A function wrapper to make","settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode","nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe","register = template.Library() def make_safe(f): \"\"\" A function wrapper to make typogrify play","amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from","from functools import wraps from django.conf import settings from django import template from","import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \"\"\" A","from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \"\"\" A function wrapper","from typogrify.filters import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools","django's unicode support. \"\"\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True","e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps',","import settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding import","force_unicode register = template.Library() def make_safe(f): \"\"\" A function wrapper to make typogrify","typogrify play nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text =","wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants))","if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper","= force_unicode(text) f.is_safe = True out = text try: out = f(text) except","initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import","= f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out)","widont, TypogrifyError from functools import wraps from django.conf import settings from django import","wrapper(text): text = force_unicode(text) f.is_safe = True out = text try: out =","import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library()","settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp',","wraps from django.conf import settings from django import template from django.utils.safestring import mark_safe","out = text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise","wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify))","return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps))","import wraps from django.conf import settings from django import template from django.utils.safestring import","raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp))","django.conf import settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding","TypogrifyError from functools import wraps from django.conf import settings from django import template","django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \"\"\" A function wrapper to","from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f):"],"string":"[\n \"force_unicode(text) f.is_safe = True out = text try: out = f(text) except TypogrifyError,\",\n \"template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify play nice with\",\n \"make typogrify play nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text\",\n \"f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe\",\n \"import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps\",\n \"unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out\",\n \"\\\"\\\"\\\" A function wrapper to make typogrify play nice with django's unicode support.\",\n \"typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings from django\",\n \"play nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text)\",\n \"django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register =\",\n \"typogrify.filters import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import\",\n \"True out = text try: out = f(text) except TypogrifyError, e: if settings.DEBUG:\",\n \"@wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out = text try:\",\n \"from django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register\",\n \"django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\"\",\n \"def wrapper(text): text = force_unicode(text) f.is_safe = True out = text try: out\",\n \"out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return\",\n \"caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf\",\n \"f.is_safe = True out = text try: out = f(text) except TypogrifyError, e:\",\n \"make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify)) register.filter('widont', make_safe(widont))\",\n \"A function wrapper to make typogrify play nice with django's unicode support. \\\"\\\"\\\"\",\n \"return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify',\",\n \"mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants',\",\n \"from django.conf import settings from django import template from django.utils.safestring import mark_safe from\",\n \"TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True\",\n \"text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return\",\n \"function wrapper to make typogrify play nice with django's unicode support. \\\"\\\"\\\" @wraps(f)\",\n \"text = force_unicode(text) f.is_safe = True out = text try: out = f(text)\",\n \"make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify play nice with django's unicode\",\n \"True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase))\",\n \"\\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out = text\",\n \"wrapper to make typogrify play nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def\",\n \"mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A function\",\n \"smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings\",\n \"functools import wraps from django.conf import settings from django import template from django.utils.safestring\",\n \"to make typogrify play nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text):\",\n \"template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def\",\n \"support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True out =\",\n \"= True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase',\",\n \"titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import settings from\",\n \"register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify)) register.filter('widont',\",\n \"e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return\",\n \"except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe =\",\n \"with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe =\",\n \"= template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify play nice\",\n \"def make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify play nice with django's\",\n \"text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes',\",\n \"= text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e\",\n \"return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes))\",\n \"try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text\",\n \"= True out = text try: out = f(text) except TypogrifyError, e: if\",\n \"import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to make\",\n \"settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode\",\n \"nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe\",\n \"register = template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify play\",\n \"amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from\",\n \"from functools import wraps from django.conf import settings from django import template from\",\n \"import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A\",\n \"from django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper\",\n \"from typogrify.filters import amp, caps, initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools\",\n \"django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text = force_unicode(text) f.is_safe = True\",\n \"e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps',\",\n \"import settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding import\",\n \"force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to make typogrify\",\n \"typogrify play nice with django's unicode support. \\\"\\\"\\\" @wraps(f) def wrapper(text): text =\",\n \"wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants))\",\n \"if settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper\",\n \"= force_unicode(text) f.is_safe = True out = text try: out = f(text) except\",\n \"initial_quotes, smartypants, titlecase, typogrify, widont, TypogrifyError from functools import wraps from django.conf import\",\n \"= f(text) except TypogrifyError, e: if settings.DEBUG: raise e return text return mark_safe(out)\",\n \"widont, TypogrifyError from functools import wraps from django.conf import settings from django import\",\n \"wrapper(text): text = force_unicode(text) f.is_safe = True out = text try: out =\",\n \"import template from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library()\",\n \"settings.DEBUG: raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp',\",\n \"wraps from django.conf import settings from django import template from django.utils.safestring import mark_safe\",\n \"out = text try: out = f(text) except TypogrifyError, e: if settings.DEBUG: raise\",\n \"wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps)) register.filter('initial_quotes', make_safe(initial_quotes)) register.filter('smartypants', make_safe(smartypants)) register.filter('titlecase', make_safe(titlecase)) register.filter('typogrify', make_safe(typogrify))\",\n \"return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp)) register.filter('caps', make_safe(caps))\",\n \"import wraps from django.conf import settings from django import template from django.utils.safestring import\",\n \"raise e return text return mark_safe(out) wrapper.is_safe = True return wrapper register.filter('amp', make_safe(amp))\",\n \"django.conf import settings from django import template from django.utils.safestring import mark_safe from django.utils.encoding\",\n \"TypogrifyError from functools import wraps from django.conf import settings from django import template\",\n \"django.utils.encoding import force_unicode register = template.Library() def make_safe(f): \\\"\\\"\\\" A function wrapper to\",\n \"from django.utils.safestring import mark_safe from django.utils.encoding import force_unicode register = template.Library() def make_safe(f):\"\n]","isConversational":false}}},{"rowIdx":2495,"cells":{"ngram":{"kind":"list like","value":["matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 - 5 ->","order to represent large data sets efficiently, e.g. in # the context of","mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max","header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h',","Compared to the # original file version \"1\", file versions 2 and higher","header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\"Slice1CenterX\"]","value) is # represented in 1 byte. The data is organized in three","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] !=","The current # version of VMR files is \"4\", which is only slightly","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] =","intensity values are stored as a series of bytes. See the V16 format","data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data","f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4))","file format.\"\"\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string)","VMR data sets with minimal header # checking if the extended information is","= data # Slice row direction vector X component data, = struct.unpack('<f', f.read(4))","the internal BrainVoyager (BV) format. # The mapping to Talairach axes is as","(4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data =","intensity value with two bytes (short # integers). The VMR format contains a","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store","Voxel resolution along Z axis # Expected binary data: char (1 byte) data,","data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"]","= header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data:","below). Version 3 added offset values to # format 2 in order to","in BrainVoyager QX for spatial transformation and # coregistration routines as well as","= np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], =","actual data followed by a second, more extensive, header. The current # version","binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary","is not needed. The information # in the post-data header contains position information","coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row direction vector","component # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"]","data is organized in three loops: # DimZ # DimY # DimX #","file version \"2\". # Expected binary data: short int (2 bytes) data, =","each dimension as well as a value indicating the size of a cube","BV (Y top -> bottom) [axis 1 after np.reshape] = Z in Tal","in the post-data header contains position information (if available) # and stores a","for # each dimension as well as a value indicating the size of","# Transformation values are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j","0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data =","(Z left -> right) [axis 0 after np.reshape] = X in Tal space","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data #","# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is #","= struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along Y axis data,","in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice","Affine transformation (16 values, 4x4 matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach","NOTE(Developer Guide 2.6): The first four entries of the post-data # header are","data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data","# left-right convention, the reference space (e.g. Talairach after # normalization) and voxel","= read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int (4 bytes) data,","Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] =","= data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):","data)) # Expected binary data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data))","axes labels in these entries are not in # terms of BrainVoyager's internal","values are stored as a series of bytes. See the V16 format #","f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from","struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of rows of slice image matrix","VMR (e.g. ACPC transformation). Finally, additional # information further descries the data set,","= [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes)","after np.reshape] = X in Tal space # Expected binary data: unsigned char","Version 3 added offset values to # format 2 in order to represent","f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B',","(4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data","many # subsequent values define the transformation: # \"1\": Rigid body+scale (3 translation,","# First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data","Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data","header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int","position information from the original file headers, e.g. from # DICOM files. The","= struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column direction vector Z component","header followed by the # actual data followed by a second, more extensive,","# Field of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4))","bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: #","of slice image matrix # Expected binary data: float (4 bytes) data, =","# Expected binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data","four entries have been added in # file version \"3\" with BrainVoyager QX","to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img","column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness","--------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected binary data: short int (2","not in # terms of BrainVoyager's internal conventions but follow the DICOM #","= header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data =","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit","is only slightly different from # version 3 (as indicated below). Version 3","data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data #","--------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3: #","--------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard data_img =","f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data","axes labels are in terms of # BrainVoyager's internal format. These four entries","= header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f',","# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] =","header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected","= struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of view extent in column","data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes)","version\"] >= 3: # Expected binary data: short int (2 bytes) data =","header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f',","Talairach transformation # \"5\": Un-Talairach transformation (1 - 5 -> BV axes) header[\"PastTransformation\"]","= struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice center Y coordinate data,","data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes)","= data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] =","bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data =","[axis 1 after np.reshape] = Z in Tal space # BV (Z left","contain anatomical 3D data sets, # typically containing the whole brain (head) of","set, including the assumed # left-right convention, the reference space (e.g. Talairach after","--------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files","# coregistration routines as well as for proper visualization. # Expected binary data:","X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column direction","The # \"type of transformation\" is a value determining how many # subsequent","Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation","to create the # current VMR (e.g. ACPC transformation). Finally, additional # information","(4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data","transformation (1 - 5 -> BV axes) header[\"PastTransformation\"] = [] for i in","header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char","actual data (\"post-data # header\"). This allows to read VMR data sets with","the post-data header contains position information (if available) # and stores a series","slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First","= struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along Z axis #","data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"]","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i',","data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice center X coordinate","# Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data #","::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # ---------------------------------------------------------------------","data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int","intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity","standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV","# Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data","Tal space # BV (Z left -> right) [axis 0 after np.reshape] =","data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i',","loops: # DimZ # DimY # DimX # # The axes terminology follows","added in # file version \"3\" with BrainVoyager QX 1.7. All other entries","= data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2))","1)) # BV to Tal # Expected binary data: unsigned char (1 byte)","Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- #","resolution along Z axis # Expected binary data: char (1 byte) data, =","\"2\". # Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2))","version of VMR files is \"4\", which is only slightly different from #","large data sets efficiently, e.g. in # the context of advanced segmentation processing.","Guide 2.6): The first four entries of the post-data # header are new","struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center X coordinate data, =","BV (X front -> back) [axis 2 after np.reshape] = Y in Tal","# integers). The VMR format contains a small header followed by the #","Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data #","f.read(4)) header[\"RowDirX\"] = data # Slice row direction vector X component data, =","= header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f',","Gap thickness [mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] =","voxel resolution. if header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6): These four","the # actual data followed by a second, more extensive, header. The current","# Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] =","DICOM # standard. Then follows eventually a section listing spatial # transformations which","= data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data","= header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data =","f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data #","data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"]","set will be internally \"expanded\" # for certain operations. The axes labels are","= struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] =","read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int (4 bytes) data, =","= header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f',","with BrainVoyager QX 1.7. All other entries are # identical to file version","header[\"GapThickness\"] = data # Gap thickness [mm] # Expected binary data: int (4","header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img","struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center Y coordinate data, =","= data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"]","data # Slice column direction vector Z component # Expected binary data: int","intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity","data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"]","numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR","e.g. from # DICOM files. The coordinate axes labels in these entries are","space # BV (Z left -> right) [axis 0 after np.reshape] = X","1 byte. The data is organized in three loops: # DimZ # DimY","float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data","data: short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"]","slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice","which have been eventually performed to create the # current VMR (e.g. ACPC","eventually performed to create the # current VMR (e.g. ACPC transformation). Finally, additional","Expected binary data: short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data","format # for a version storing each intensity value with two bytes (short","First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data #","header contains position information (if available) # and stores a series of spatial","f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4","series of spatial transformations, which might have been # performed to the original","binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data #","--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, #","# First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data","2 and higher contain # additional header information after the actual data (\"post-data","char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B',","\"\"\"Read, write, create Brainvoyager VMR file format.\"\"\" import struct import numpy as np","Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column direction","data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int (4","struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along Z axis # Expected","= header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data:","data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img =","right) [axis 0 after np.reshape] = X in Tal space # Expected binary","the transformation: # \"1\": Rigid body+scale (3 translation, 3 rotation, 3 scale) #","trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4","# DimX # # The axes terminology follows the internal BrainVoyager (BV) format.","data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along Z axis","read VMR data sets with minimal header # checking if the extended information","= header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data:","= header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f',","int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored","Expected binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data =","the # information specified in the following table is stored. The # \"type","coregistration routines as well as for proper visualization. # Expected binary data: unsigned","of # BrainVoyager's internal format. These four entries are followed by # scan","Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data","of VMR files is \"4\", which is only slightly different from # version","# Expected binary data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data","struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column direction vector X component data,","top -> bottom) [axis 1 after np.reshape] = Z in Tal space #","- 5 -> BV axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict())","direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of view","Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data",": numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- #","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data","The data is organized in three loops: # DimZ # DimY # DimX","version \"1\", file versions 2 and higher contain # additional header information after","after the actual data (\"post-data # header\"). This allows to read VMR data","as follows: # BV (X front -> back) [axis 2 after np.reshape] =","Rigid body+scale (3 translation, 3 rotation, 3 scale) # \"2\": Affine transformation (16","direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice","VMR files contain anatomical 3D data sets, # typically containing the whole brain","# # The axes terminology follows the internal BrainVoyager (BV) format. # The","def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to","dimension as well as a value indicating the size of a cube with","header are new since file version \"3\" and contain offset values for #","0 after np.reshape] = X in Tal space # Expected binary data: unsigned","= struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char (1","entries are followed by # scan position information from the original file headers,","data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- #","a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data:","header, data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string","# ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters","coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center Y","struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data #","# additional header information after the actual data (\"post-data # header\"). This allows","header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\"FoVRows\"]","body+scale (3 translation, 3 rotation, 3 scale) # \"2\": Affine transformation (16 values,","Field of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"]","============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path","# actual data followed by a second, more extensive, header. The current #","VMR files is \"4\", which is only slightly different from # version 3","binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"]","unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data","of a cube with # iso-dimensions to which the data set will be","bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected","= header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data =","four entries of the post-data # header are new since file version \"3\"","# First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data","# --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The","# NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented in","--------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short","column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data #","thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm]","data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center X coordinate","after # normalization) and voxel resolution. if header[\"File version\"] >= 3: # NOTE(Developer","values as a list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected","data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] =","data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] =","row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data #","data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer","# terms of BrainVoyager's internal conventions but follow the DICOM # standard. Then","files contain anatomical 3D data sets, # typically containing the whole brain (head)","is as follows: # BV (X front -> back) [axis 2 after np.reshape]","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] =","header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string","float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data))","3 rotation, 3 scale) # \"2\": Affine transformation (16 values, 4x4 matrix) #","bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected","= trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1))","format 2 in order to represent large data sets efficiently, e.g. in #","These four entries are followed by # scan position information from the original","checking if the extended information is not needed. The information # in the","center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice","Parameters ---------- filename : string Path to file. Returns ------- header : dictionary","Un-Talairach transformation (1 - 5 -> BV axes) header[\"PastTransformation\"] = [] for i","(4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary","segmentation processing. Compared to the # original file version \"1\", file versions 2","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data #","header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data))","Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data #","data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes)","data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data","header[\"VoxelSizeZ\"] = data # Voxel resolution along Z axis # Expected binary data:","f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data: float (4 bytes) data, =","= struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data: float (4 bytes)","\"4\", which is only slightly different from # version 3 (as indicated below).","brain (head) of subjects. The # intensity values are stored as a series","data set (\"history record\"). The # post-header data can be probably ignored for","header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","the V16 format # for a version storing each intensity value with two","new in v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f',","data)) # Transformation values are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for","= struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row direction vector Z component","f.read(4)) header[\"Slice1CenterY\"] = data # First slice center Y coordinate data, = struct.unpack('<f',","modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in","have been added in # file version \"3\" with BrainVoyager QX 1.7. All","\"2\": Affine transformation (16 values, 4x4 matrix) # \"4\": Talairach transformation # \"5\":","data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte)","# normalization) and voxel resolution. if header[\"File version\"] >= 3: # NOTE(Developer Guide","# Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"]","# Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected","= struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center X coordinate data,","(16 values, 4x4 matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1","the # current VMR (e.g. ACPC transformation). Finally, additional # information further descries","further descries the data set, including the assumed # left-right convention, the reference","f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int (4 bytes) data, =","data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"]","data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center Z coordinate","to which the data set will be internally \"expanded\" # for certain operations.","to Tal # Expected binary data: unsigned char (1 byte) data_img = data_img.flatten()","the post-data # header are new since file version \"3\" and contain offset","in three loops: # DimZ # DimY # DimX # # The axes","might have been # performed to the original data set (\"history record\"). The","view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data","(2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H',","of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] =","original file version \"1\", file versions 2 and higher contain # additional header","data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data","along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of rows","anatomical 3D data sets, # typically containing the whole brain (head) of subjects.","# NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, # typically","-> BV axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected","header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img","2.6): The first four entries of the post-data # header are new since","transformation (16 values, 4x4 matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation","binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"]","# --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3:","(1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # ---------------------------------------------------------------------","represent large data sets efficiently, e.g. in # the context of advanced segmentation","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data","custom routines, but is # important in BrainVoyager QX for spatial transformation and","f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f',","header # checking if the extended information is not needed. The information #","header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary","data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as a","# VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int","data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"]","if the extended information is not needed. The information # in the post-data","header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data))","header : dictionary Header of VMR file. data_img : numpy.array, 3D Image. \"\"\"","these entries are not in # terms of BrainVoyager's internal conventions but follow","data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i',","f.read(4)) header[\"NCols\"] = data # Nr of columns of slice image matrix #","# performed to the original data set (\"history record\"). The # post-header data","in Tal space # BV (Z left -> right) [axis 0 after np.reshape]","matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of columns of","for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) data, =","Nr of columns of slice image matrix # Expected binary data: float (4","data # Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4))","4x4 matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 - 5","---------- filename : string Output filename. header : dictionary Header of VMR file.","= data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"]","write, create Brainvoyager VMR file format.\"\"\" import struct import numpy as np from","(if available) # and stores a series of spatial transformations, which might have","data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are","values define the transformation: # \"1\": Rigid body+scale (3 translation, 3 rotation, 3","# Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) #","f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected","back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes","-> bottom) [axis 1 after np.reshape] = Z in Tal space # BV","data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"]","axes is as follows: # BV (X front -> back) [axis 2 after","data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"]","entries of the post-data # header are new since file version \"3\" and","-> back) [axis 2 after np.reshape] = Y in Tal space # BV","in order to represent large data sets efficiently, e.g. in # the context","3D Image. \"\"\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data","data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1))","Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] *","different from # version 3 (as indicated below). Version 3 added offset values","file headers, e.g. from # DICOM files. The coordinate axes labels in these","f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4","data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f',","scale) # \"2\": Affine transformation (16 values, 4x4 matrix) # \"4\": Talairach transformation","version storing each intensity value with two bytes (short # integers). The VMR","to file. Returns ------- header : dictionary Pre-data and post-data headers. data :","(\"post-data # header\"). This allows to read VMR data sets with minimal header","char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) #","transformations which have been eventually performed to create the # current VMR (e.g.","image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of columns","struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data,","f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as a list trans_values =","are new since file version \"3\" and contain offset values for # each","bytes. See the V16 format # for a version storing each intensity value","internal format. These four entries are followed by # scan position information from","important in BrainVoyager QX for spatial transformation and # coregistration routines as well","data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4 data, =","header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f,","will be internally \"expanded\" # for certain operations. The axes labels are in","DimY # DimX # # The axes terminology follows the internal BrainVoyager (BV)","header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float","# \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 - 5 -> BV","as for proper visualization. # Expected binary data: unsigned short int (2 bytes)","f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4))","scan position information from the original file headers, e.g. from # DICOM files.","= struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column direction vector X component","dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm]","= data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] =","QX 1.7. All other entries are # identical to file version \"2\". #","float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected","format.\"\"\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) #","allows to read VMR data sets with minimal header # checking if the","minimal header # checking if the extended information is not needed. The information","data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string Output","= struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row direction vector Y component","stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected","from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file.","data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column direction vector Y","coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center Z","write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i',","data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary","struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data #","data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data =","# Expected binary data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data","# Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected","size of a cube with # iso-dimensions to which the data set will","V16 format # for a version storing each intensity value with two bytes","= header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes)","organized in three loops: # DimZ # DimY # DimX # # The","component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column direction vector","struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char (1 byte)","# Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) #","which is only slightly different from # version 3 (as indicated below). Version","f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity return header, data_img #","header[\"ReferenceSpaceVMR\"] = data # new in v4 # Expected binary data: float (4","header[\"File version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, =","entries have been added in # file version \"3\" with BrainVoyager QX 1.7.","header[\"Slice1CenterX\"] = data # First slice center X coordinate data, = struct.unpack('<f', f.read(4))","columns of slice image matrix # Expected binary data: float (4 bytes) data,","values are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]):","header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape(","# BV (X front -> back) [axis 2 after np.reshape] = Y in","center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice","# --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data","as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary","contains position information (if available) # and stores a series of spatial transformations,","added offset values to # format 2 in order to represent large data","data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] =","# VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to","--------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element","including the assumed # left-right convention, the reference space (e.g. Talairach after #","data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data =","[mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm] data,","data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] =","# scan position information from the original file headers, e.g. from # DICOM","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"]","(4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string","data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"]","(X front -> back) [axis 2 after np.reshape] = Y in Tal space","filename : string Output filename. header : dictionary Header of VMR file. data_img","bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along X","data # Store transformation values as a list trans_values = [] for j","= struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length string data","--------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data = header[\"File","struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4))","four entries are followed by # scan position information from the original file","(4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data","axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data:","data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] =","data: unsigned short int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data","3 (as indicated below). Version 3 added offset values to # format 2","# Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] =","value with two bytes (short # integers). The VMR format contains a small","post-header data can be probably ignored for custom routines, but is # important","# format 2 in order to represent large data sets efficiently, e.g. in","are in terms of # BrainVoyager's internal format. These four entries are followed","= struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data","DICOM files. The coordinate axes labels in these entries are not in #","# The mapping to Talairach axes is as follows: # BV (X front","f.read(4)) header[\"Slice1CenterX\"] = data # First slice center X coordinate data, = struct.unpack('<f',","------- header : dictionary Pre-data and post-data headers. data : 3D numpy.array Image","binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"]","# BV (Z left -> right) [axis 0 after np.reshape] = X in","with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # ---------------------------------------------------------------------","struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int (4 bytes) data,","header : dictionary Pre-data and post-data headers. data : 3D numpy.array Image data.","have been # performed to the original data set (\"history record\"). The #","= struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, =","contain # additional header information after the actual data (\"post-data # header\"). This","3: # Expected binary data: short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h',","data sets efficiently, e.g. in # the context of advanced segmentation processing. Compared","been eventually performed to create the # current VMR (e.g. ACPC transformation). Finally,","bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as","axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected","the DICOM # standard. Then follows eventually a section listing spatial # transformations","= struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data","whole brain (head) of subjects. The # intensity values are stored as a","Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data #","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] =","bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data =","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary","data. \"\"\" header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- #","= header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"]","(intensity value) is # represented in 1 byte. The data is organized in","= data # Slice column direction vector Y component data, = struct.unpack('<f', f.read(4))","write Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header :","Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data","dictionary Pre-data and post-data headers. data : 3D numpy.array Image data. \"\"\" header","of bytes. See the V16 format # for a version storing each intensity","f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f',","struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data #","f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data,","struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data #","binary data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"]","header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data))","struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center Z coordinate data, =","for certain operations. The axes labels are in terms of # BrainVoyager's internal","= struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center Z coordinate data,","# Expected binary data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data","resolution. if header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6): These four entries","information from the original file headers, e.g. from # DICOM files. The coordinate","header[\"RowDirX\"] = data # Slice row direction vector X component data, = struct.unpack('<f',","= data # Slice row direction vector Z component data, = struct.unpack('<f', f.read(4))","each past transformation, the # information specified in the following table is stored.","terms of BrainVoyager's internal conventions but follow the DICOM # standard. Then follows","The # post-header data can be probably ignored for custom routines, but is","(0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] #","rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data #","header[\"SliceNCenterX\"] = data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4))","# transformations which have been eventually performed to create the # current VMR","(4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data","1 after np.reshape] = Z in Tal space # BV (Z left ->","data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f',","The first four entries of the post-data # header are new since file","dictionary Header of VMR file. data_img : numpy.array, 3D Image. \"\"\" with open(filename,","binary data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"]","# 16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header,","VMR format contains a small header followed by the # actual data followed","row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data #","\"3\" with BrainVoyager QX 1.7. All other entries are # identical to file","vector Z component # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","# Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] =","= np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary data:","data # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"]","Expected binary data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data =","filename. header : dictionary Header of VMR file. data_img : numpy.array, 3D Image.","f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i',","in # the context of advanced segmentation processing. Compared to the # original","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data #","typically containing the whole brain (head) of subjects. The # intensity values are","f.read(4)) header[\"FoVRows\"] = data # Field of view extent in row direction [mm]","for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j]))","data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data =","data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary","data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center Z coordinate","min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean","= header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data =","f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data","# Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"]","struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data,","data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row direction vector Y","filename : string Path to file. Returns ------- header : dictionary Pre-data and","variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int (4","= data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data:","f.read(4)) header[\"FoVCols\"] = data # Field of view extent in column dir. [mm]","f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data","struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6):","and stores a series of spatial transformations, which might have been # performed","vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row","followed by a second, more extensive, header. The current # version of VMR","component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row direction vector","Guide 2.6): For each past transformation, the # information specified in the following","Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D","(1 - 5 -> BV axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]):","# 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data #","# intensity values are stored as a series of bytes. See the V16","header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h',","data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes)","= header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f',","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data:","= data # Slice row direction vector Y component data, = struct.unpack('<f', f.read(4))","binary data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"]","data : 3D numpy.array Image data. \"\"\" header = dict() with open(filename, 'rb')","for proper visualization. # Expected binary data: unsigned short int (2 bytes) data,","char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data))","Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected","are stored as a series of bytes. See the V16 format # for","slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last","= header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR","int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length","VMR file format.\"\"\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string,","data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data,","'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected","variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int","data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data","!= 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data","# Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data:","create Brainvoyager VMR file format.\"\"\" import struct import numpy as np from bvbabel.utils","X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row direction","data # Nr of columns of slice image matrix # Expected binary data:","[mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of view extent","i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f)","These four entries have been added in # file version \"3\" with BrainVoyager","data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary","f.read(4)) header[\"ColDirY\"] = data # Slice column direction vector Y component data, =","= data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For each past","* header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img =","as well as for proper visualization. # Expected binary data: unsigned short int","data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary","data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data: int","vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column","f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) #","f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length string data = read_variable_length_string(f)","Brainvoyager VMR file format.\"\"\" import struct import numpy as np from bvbabel.utils import","values for # each dimension as well as a value indicating the size","NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, # typically containing","follows eventually a section listing spatial # transformations which have been eventually performed","version \"2\". # Expected binary data: short int (2 bytes) data, = struct.unpack('<h',","binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data #","data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes)","data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr","DimX # # The axes terminology follows the internal BrainVoyager (BV) format. #","struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length string data =","1.7. All other entries are # identical to file version \"2\". # Expected","Expected binary data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data =","f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data","resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel","bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data","f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4 # Expected binary data: float","be probably ignored for custom routines, but is # important in BrainVoyager QX","data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] =","= read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int (4 bytes) data,","f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4","data (\"post-data # header\"). This allows to read VMR data sets with minimal","data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes)","struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data,","np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary data: unsigned","= header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data:","'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer","= struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as a list","data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center Y coordinate","= struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row direction vector X component","Image. \"\"\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header","data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity data,","= [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string","new since file version \"3\" and contain offset values for # each dimension","data # Voxel resolution along Z axis # Expected binary data: char (1","in these entries are not in # terms of BrainVoyager's internal conventions but","space (e.g. Talairach after # normalization) and voxel resolution. if header[\"File version\"] >=","= np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1,","data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data =","section listing spatial # transformations which have been eventually performed to create the","processing. Compared to the # original file version \"1\", file versions 2 and","data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # ---------------------------------------------------------------------",": 3D numpy.array Image data. \"\"\" header = dict() with open(filename, 'rb') as","struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along Y axis data, =","Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data","iso-dimensions to which the data set will be internally \"expanded\" # for certain","if header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have","binary data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"]","header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"] f.write(struct.pack('<i', data))","header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"]","data)) # Expected binary data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data))","(\"history record\"). The # post-header data can be probably ignored for custom routines,","The axes terminology follows the internal BrainVoyager (BV) format. # The mapping to","data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column direction vector Z","= data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"]","data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int","data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"]","headers. data : 3D numpy.array Image data. \"\"\" header = dict() with open(filename,","The coordinate axes labels in these entries are not in # terms of","# DICOM files. The coordinate axes labels in these entries are not in","format. # The mapping to Talairach axes is as follows: # BV (X","routines, but is # important in BrainVoyager QX for spatial transformation and #","Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data","coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center X","bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H', f.read(2))","= header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values","data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data","struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1))","= data # Field of view extent in column dir. [mm] data, =","= header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h',","transformation values as a list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): #","but follow the DICOM # standard. Then follows eventually a section listing spatial","header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float","a value indicating the size of a cube with # iso-dimensions to which","list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float","binary data: unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size):","(4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored as",": dictionary Header of VMR file. data_img : numpy.array, 3D Image. \"\"\" with","coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice center Y","is # important in BrainVoyager QX for spatial transformation and # coregistration routines","table is stored. The # \"type of transformation\" is a value determining how","as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide","integers). The VMR format contains a small header followed by the # actual","past transformation, the # information specified in the following table is stored. The","string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int (4","np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B',","int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data))","data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"]","Tal # Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for","# Voxel resolution along Z axis # Expected binary data: char (1 byte)","format contains a small header followed by the # actual data followed by","f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected","Z axis # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1))","list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float","data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"]","= header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data =","Returns ------- header : dictionary Pre-data and post-data headers. data : 3D numpy.array","the assumed # left-right convention, the reference space (e.g. Talairach after # normalization)","::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV","header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide","# DimY # DimX # # The axes terminology follows the internal BrainVoyager","of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] =","# Expected binary data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data","back) [axis 2 after np.reshape] = Y in Tal space # BV (Y","center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice","f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center Y coordinate data, = struct.unpack('<f',","vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column","struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column direction vector Y component data,","f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2,","the original data set (\"history record\"). The # post-header data can be probably","= Z in Tal space # BV (Z left -> right) [axis 0","available) # and stores a series of spatial transformations, which might have been","The information # in the post-data header contains position information (if available) #","# 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data #","component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column direction vector","the data set will be internally \"expanded\" # for certain operations. The axes","data: unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B',","is \"4\", which is only slightly different from # version 3 (as indicated","# Expected binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data","data = header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data =","# new in v4 # Expected binary data: float (4 bytes) data, =","byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4 data,","(as indicated below). Version 3 added offset values to # format 2 in","# version 3 (as indicated below). Version 3 added offset values to #","Y in Tal space # BV (Y top -> bottom) [axis 1 after","header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"]","data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data: float (4","direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice","the context of advanced segmentation processing. Compared to the # original file version","bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of view extent","current VMR (e.g. ACPC transformation). Finally, additional # information further descries the data","header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data))","= Y in Tal space # BV (Y top -> bottom) [axis 1","= data # First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"]","data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i],","column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data #","entries are # identical to file version \"2\". # Expected binary data: short","1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV","struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of view extent in column dir.","as a series of bytes. See the V16 format # for a version","binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1","versions 2 and higher contain # additional header information after the actual data","struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity data, = struct.unpack('<i',","= data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data","slightly different from # version 3 (as indicated below). Version 3 added offset","data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of rows of slice","data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"]","[axis 0 after np.reshape] = X in Tal space # Expected binary data:","range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) #","float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data))","(2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data","= data # Field of view extent in row direction [mm] data, =","f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B',","identical to file version \"2\". # Expected binary data: short int (2 bytes)","The # intensity values are stored as a series of bytes. See the","Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of","# NOTE(Developer Guide 2.6): For each past transformation, the # information specified in","after np.reshape] = Y in Tal space # BV (Y top -> bottom)","char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in","center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice","VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2","matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"]","direction vector Z component # Expected binary data: int (4 bytes) data, =","transformation # \"5\": Un-Talairach transformation (1 - 5 -> BV axes) header[\"PastTransformation\"] =","original data set (\"history record\"). The # post-header data can be probably ignored","followed by the # actual data followed by a second, more extensive, header.","= struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along X axis data,","= data # 16-bit data max intensity return header, data_img # ============================================================================= def","Parameters ---------- filename : string Output filename. header : dictionary Header of VMR","header[\"SliceNCenterY\"] = data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4))","header[\"File version\"] >= 3: # Expected binary data: short int (2 bytes) data","direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice","specified in the following table is stored. The # \"type of transformation\" is","range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img","data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data =","See the V16 format # for a version storing each intensity value with","information specified in the following table is stored. The # \"type of transformation\"","# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets,","extensive, header. The current # version of VMR files is \"4\", which is","# --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR","byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- #","= data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data","data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR","float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data))","for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header #","struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column direction vector Z component #","data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- #","component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column direction vector","data # Field of view extent in row direction [mm] data, = struct.unpack('<f',","# \"2\": Affine transformation (16 values, 4x4 matrix) # \"4\": Talairach transformation #","binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values","is stored. The # \"type of transformation\" is a value determining how many","Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is","NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented in 1","data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data","i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"],","the original file headers, e.g. from # DICOM files. The coordinate axes labels","for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data =","struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row direction vector Y component data,","is a value determining how many # subsequent values define the transformation: #","16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit","= data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data","data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i',","storing each intensity value with two bytes (short # integers). The VMR format","file. Parameters ---------- filename : string Path to file. Returns ------- header :","to write Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header","normalization) and voxel resolution. if header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6):","\"expanded\" # for certain operations. The axes labels are in terms of #","binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values","header[\"ColDirZ\"] = data # Slice column direction vector Z component # Expected binary","binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data,","data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] =","sets efficiently, e.g. in # the context of advanced segmentation processing. Compared to","2 after np.reshape] = Y in Tal space # BV (Y top ->","slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last","f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center Z coordinate data, = struct.unpack('<f',","\"1\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \"2\": Affine transformation","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values","header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data))","f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4","(1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) #","import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ----------","= struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of view extent in row","is # represented in 1 byte. The data is organized in three loops:","data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along Y axis","Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for i in","header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data))","data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary","file version \"3\" with BrainVoyager QX 1.7. All other entries are # identical","data sets with minimal header # checking if the extended information is not","VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries","Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data","of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data","f.read(4)) header[\"ColDirZ\"] = data # Slice column direction vector Z component # Expected","struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice center X coordinate data, =","data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data =","VMR file. Parameters ---------- filename : string Path to file. Returns ------- header","and contain offset values for # each dimension as well as a value","view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data","information (if available) # and stores a series of spatial transformations, which might","Expected binary data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data =","f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data)","create the # current VMR (e.g. ACPC transformation). Finally, additional # information further","struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data","performed to create the # current VMR (e.g. ACPC transformation). Finally, additional #","trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"]","int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data data, =","data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, =","data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int","Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary","header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data","if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length","data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] =","in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"]","-> right) [axis 0 after np.reshape] = X in Tal space # Expected","Field of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"]","not needed. The information # in the post-data header contains position information (if","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data","center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice","= data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR","spatial # transformations which have been eventually performed to create the # current","\"\"\" header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR","# Slice column direction vector Z component # Expected binary data: int (4","Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data","# Store transformation values as a list trans_values = [] for j in","determining how many # subsequent values define the transformation: # \"1\": Rigid body+scale","# modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new","header[\"CoordinateSystem\"] = data # Expected binary data: float (4 bytes) data, = struct.unpack('<f',","2, 1)) # BV to Tal # Expected binary data: unsigned char (1","j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) #","value determining how many # subsequent values define the transformation: # \"1\": Rigid","header[\"ColDirX\"] = data # Slice column direction vector X component data, = struct.unpack('<f',","data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data:","data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1,","= header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data =","the extended information is not needed. The information # in the post-data header","a value determining how many # subsequent values define the transformation: # \"1\":","in v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))","header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data","followed by # scan position information from the original file headers, e.g. from","# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"]","probably ignored for custom routines, but is # important in BrainVoyager QX for","Expected binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data =","Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along","values, 4x4 matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 -","in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4","[] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data","series of bytes. See the V16 format # for a version storing each","in # file version \"3\" with BrainVoyager QX 1.7. All other entries are","= struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide","which might have been # performed to the original data set (\"history record\").","set (\"history record\"). The # post-header data can be probably ignored for custom","version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data))","bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data","open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- #","component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row direction vector","Tal space # BV (Y top -> bottom) [axis 1 after np.reshape] =","f.read(4)) header[\"ColDirX\"] = data # Slice column direction vector X component data, =","data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"]","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of","Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer","# each dimension as well as a value indicating the size of a","= struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4 data, = struct.unpack('<B',","= struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data: int (4 bytes)","= header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data =","data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm] # Expected","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] =","translation, 3 rotation, 3 scale) # \"2\": Affine transformation (16 values, 4x4 matrix)","2.6): VMR files contain anatomical 3D data sets, # typically containing the whole","a list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data:","binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data:","been added in # file version \"3\" with BrainVoyager QX 1.7. All other","data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data","[axis 2 after np.reshape] = Y in Tal space # BV (Y top","3D numpy.array Image data. \"\"\" header = dict() with open(filename, 'rb') as f:","0: # NOTE(Developer Guide 2.6): For each past transformation, the # information specified","in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"]))","byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"]","Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary","f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f',","header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary","data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity data,","transformation). Finally, additional # information further descries the data set, including the assumed","data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data","BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img =","def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename","spatial transformation and # coregistration routines as well as for proper visualization. #","ignored for custom routines, but is # important in BrainVoyager QX for spatial","= data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2))","other entries are # identical to file version \"2\". # Expected binary data:","= struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data","file. Parameters ---------- filename : string Output filename. header : dictionary Header of","data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] =","post-data headers. data : 3D numpy.array Image data. \"\"\" header = dict() with","f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data","header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"]","slice image matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f',","since file version \"3\" and contain offset values for # each dimension as","Expected binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"]","binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data #","float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice","float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution","(1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) #","\"type of transformation\" is a value determining how many # subsequent values define","data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) # ---------------------------------------------------------------------","header[\"Slice1CenterY\"] = data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4))","# The axes terminology follows the internal BrainVoyager (BV) format. # The mapping","# Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"]","header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data))","short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File version\"] = data data,","header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"]","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4))","in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field","header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as a list trans_values = []","header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"]","and # coregistration routines as well as for proper visualization. # Expected binary","offset values to # format 2 in order to represent large data sets","well as for proper visualization. # Expected binary data: unsigned short int (2","= header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data =","np.reshape] = Y in Tal space # BV (Y top -> bottom) [axis","= struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity data, =","# VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected","internal BrainVoyager (BV) format. # The mapping to Talairach axes is as follows:","for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"]","binary data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]),","the # original file version \"1\", file versions 2 and higher contain #","struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of view extent in row direction","header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For each","are # identical to file version \"2\". # Expected binary data: short int","header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H',","data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected","# header\"). This allows to read VMR data sets with minimal header #","data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to","string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes)","::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header #","along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution","VMR file. data_img : numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as f:","extended information is not needed. The information # in the post-data header contains","for spatial transformation and # coregistration routines as well as for proper visualization.","i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # ---------------------------------------------------------------------","data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm] data, =","= data # Gap thickness [mm] # Expected binary data: int (4 bytes)","string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes)","data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"]","indicated below). Version 3 added offset values to # format 2 in order","16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img):","data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] =","transformations, which might have been # performed to the original data set (\"history","vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice row","= struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity data, =","each intensity value with two bytes (short # integers). The VMR format contains","np.reshape] = Z in Tal space # BV (Z left -> right) [axis","BV (Z left -> right) [axis 0 after np.reshape] = X in Tal","internally \"expanded\" # for certain operations. The axes labels are in terms of","data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int (4 bytes)","= data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2))","direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] = data # Slice","= header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f',","left-right convention, the reference space (e.g. Talairach after # normalization) and voxel resolution.","extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data #","Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char","context of advanced segmentation processing. Compared to the # original file version \"1\",","contains a small header followed by the # actual data followed by a","Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes)","3 scale) # \"2\": Affine transformation (16 values, 4x4 matrix) # \"4\": Talairach","header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img =","define the transformation: # \"1\": Rigid body+scale (3 translation, 3 rotation, 3 scale)","data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data:","standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img,","header\"). This allows to read VMR data sets with minimal header # checking","extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data #","# Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected","spatial transformations, which might have been # performed to the original data set","header[\"VoxelSizeX\"] = data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4))","trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char (1 byte) data, =","data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"] f.write(struct.pack('<i', data)) return print(\"VMR","of BrainVoyager's internal conventions but follow the DICOM # standard. Then follows eventually","= header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f',","following table is stored. The # \"type of transformation\" is a value determining","data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data","VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected binary","higher contain # additional header information after the actual data (\"post-data # header\").","vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column","struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0,","(Y top -> bottom) [axis 1 after np.reshape] = Z in Tal space","from # version 3 (as indicated below). Version 3 added offset values to","struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- #","header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"]","f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"]","The VMR format contains a small header followed by the # actual data","in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if","# BV to Tal # Expected binary data: unsigned char (1 byte) data_img","mapping to Talairach axes is as follows: # BV (X front -> back)","struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity return header, data_img","bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data:","needed. The information # in the post-data header contains position information (if available)","data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data =","bottom) [axis 1 after np.reshape] = Z in Tal space # BV (Z","return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager","= X in Tal space # Expected binary data: unsigned char (1 byte)","= header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f',","data)) # Expected binary data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data))","# Expected binary data: short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data))","= header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data =","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data #","are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): #","2.6): Each data element (intensity value) is # represented in 1 byte. The","# for certain operations. The axes labels are in terms of # BrainVoyager's","struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation values as a list trans_values","open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- #","from the original file headers, e.g. from # DICOM files. The coordinate axes","# Gap thickness [mm] # Expected binary data: int (4 bytes) data, =","= header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): #","bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"]","data # Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"]","# Expected binary data: unsigned short int (2 bytes) data = header[\"File version\"]","Expected binary data: unsigned short int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H',","Expected binary data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data =","header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data))","range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary","Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] =","to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # ---------------------------------------------------------------------","NOTE(Developer Guide 2.6): For each past transformation, the # information specified in the","header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","values to # format 2 in order to represent large data sets efficiently,","data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol","data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of view extent in","the following table is stored. The # \"type of transformation\" is a value","by a second, more extensive, header. The current # version of VMR files","data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data #","struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row direction vector X component data,","Brainvoyager VMR file. Parameters ---------- filename : string Path to file. Returns -------","# \"1\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \"2\": Affine","headers, e.g. from # DICOM files. The coordinate axes labels in these entries","# \"5\": Un-Talairach transformation (1 - 5 -> BV axes) header[\"PastTransformation\"] = []","data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"]","data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data","Pre-data and post-data headers. data : 3D numpy.array Image data. \"\"\" header =","information further descries the data set, including the assumed # left-right convention, the","data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"]","variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data: int (4","value indicating the size of a cube with # iso-dimensions to which the","data)) # Expected binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data))","to Talairach axes is as follows: # BV (X front -> back) [axis","j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f',","# Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2))","f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char (1 byte) data,","additional header information after the actual data (\"post-data # header\"). This allows to","header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data))","file. Returns ------- header : dictionary Pre-data and post-data headers. data : 3D","= struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img,","Tal space # Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"]","header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data))","data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data","header[\"LeftRightConvention\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] =","= data # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))","= data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"]","file. data_img : numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as f: #",">= 3: # Expected binary data: short int (2 bytes) data = header[\"OffsetX\"]","bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data =","string Path to file. Returns ------- header : dictionary Pre-data and post-data headers.","data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data","unsigned short int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data =","# information specified in the following table is stored. The # \"type of","5 -> BV axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) #","read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to file.","# DimZ # DimY # DimX # # The axes terminology follows the","header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity return header, data_img # =============================================================================","bytes (short # integers). The VMR format contains a small header followed by","f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"] f.write(struct.pack('<i', data)) return","data # Gap thickness [mm] # Expected binary data: int (4 bytes) data,","data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"]","as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary","data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1))","# Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data","bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data = header[\"LeftRightConvention\"]","position information (if available) # and stores a series of spatial transformations, which","data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"]","Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip","record\"). The # post-header data can be probably ignored for custom routines, but","in Tal space # Expected binary data: unsigned char (1 byte) data_img =","file version \"3\" and contain offset values for # each dimension as well","int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data))","header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data: int","header[\"NCols\"] = data # Nr of columns of slice image matrix # Expected","VMR file. Parameters ---------- filename : string Output filename. header : dictionary Header","= header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f',","axis # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"]","information is not needed. The information # in the post-data header contains position","= header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data:","data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data =","f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data:","(4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) #","\"3\" and contain offset values for # each dimension as well as a","data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data))","is organized in three loops: # DimZ # DimY # DimX # #","intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] =","f.read(4)) header[\"RowDirY\"] = data # Slice row direction vector Y component data, =","a cube with # iso-dimensions to which the data set will be internally","f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1","data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data =","version 3 (as indicated below). Version 3 added offset values to # format","header[\"RowDirZ\"] = data # Slice row direction vector Z component data, = struct.unpack('<f',","row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data #","data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation,","labels are in terms of # BrainVoyager's internal format. These four entries are","the data set, including the assumed # left-right convention, the reference space (e.g.","f.write(struct.pack('<f', data)) data = header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data","how many # subsequent values define the transformation: # \"1\": Rigid body+scale (3","2.6): These four entries have been added in # file version \"3\" with","# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the post-data","with minimal header # checking if the extended information is not needed. The","BV axes) header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary","= header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary data:","int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h',","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data","struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4 # Expected binary data:","struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit data mean intensity data, = struct.unpack('<i',","= header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f',","f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For","data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header","= data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data:","write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename :",": dictionary Pre-data and post-data headers. data : 3D numpy.array Image data. \"\"\"","# NOTE(Developer Guide 2.6): These four entries have been added in # file","# subsequent values define the transformation: # \"1\": Rigid body+scale (3 translation, 3","data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified","struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along X axis data, =","be internally \"expanded\" # for certain operations. The axes labels are in terms","f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i',","range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data)","= data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2))","= struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center Y coordinate data,","f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4","first four entries of the post-data # header are new since file version","# BrainVoyager's internal format. These four entries are followed by # scan position","and voxel resolution. if header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6): These","a small header followed by the # actual data followed by a second,","data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\")","header[\"FramingCubeDim\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data = header[\"PosInfosVerified\"]","For each past transformation, the # information specified in the following table is","--------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first","data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B',","Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness","data sets, # typically containing the whole brain (head) of subjects. The #","Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected binary data:","= struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of rows of slice image","struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of columns of slice image matrix","with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # ---------------------------------------------------------------------","write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename :","data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4 # Expected","(short # integers). The VMR format contains a small header followed by the","3D data sets, # typically containing the whole brain (head) of subjects. The","sets with minimal header # checking if the extended information is not needed.","ACPC transformation). Finally, additional # information further descries the data set, including the","header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data","post-data # header are new since file version \"3\" and contain offset values","subsequent values define the transformation: # \"1\": Rigid body+scale (3 translation, 3 rotation,","resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel","# BV (Y top -> bottom) [axis 1 after np.reshape] = Z in","Guide 2.6): Each data element (intensity value) is # represented in 1 byte.","of spatial transformations, which might have been # performed to the original data","= header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f',","Expected binary data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data =","front -> back) [axis 2 after np.reshape] = Y in Tal space #","= data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data:","f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center X coordinate data, = struct.unpack('<f',","Each data element (intensity value) is # represented in 1 byte. The data","are followed by # scan position information from the original file headers, e.g.","--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented","f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H', data)) #","\"\"\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header #","header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\"NRows\"]","Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\"File","in 1 byte. The data is organized in three loops: # DimZ #","# for a version storing each intensity value with two bytes (short #","# Expected binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if","char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data))","= struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data","Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data","f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer","# original file version \"1\", file versions 2 and higher contain # additional","Image data. \"\"\" header = dict() with open(filename, 'rb') as f: # ---------------------------------------------------------------------","# --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard","Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected","of the post-data # header are new since file version \"3\" and contain","data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] =","= struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data","= header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data)) # Expected binary data:","files. The coordinate axes labels in these entries are not in # terms","f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data","rotation, 3 scale) # \"2\": Affine transformation (16 values, 4x4 matrix) # \"4\":","struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data: int (4 bytes) data,","data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row direction vector Z","header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"]","2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip","short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h',","but is # important in BrainVoyager QX for spatial transformation and # coregistration","header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary","string Output filename. header : dictionary Header of VMR file. data_img : numpy.array,","more extensive, header. The current # version of VMR files is \"4\", which","data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR","BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide","--------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back","bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data =","byte. The data is organized in three loops: # DimZ # DimY #","# represented in 1 byte. The data is organized in three loops: #","data)) # Expected binary data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data))","bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min intensity","been # performed to the original data set (\"history record\"). The # post-header","(4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i","row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of","as a value indicating the size of a cube with # iso-dimensions to","contain offset values for # each dimension as well as a value indicating","# information further descries the data set, including the assumed # left-right convention,","header[\"FoVRows\"] = data # Field of view extent in row direction [mm] data,","data # First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] =","for a version storing each intensity value with two bytes (short # integers).","a series of spatial transformations, which might have been # performed to the","# Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] =","as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager","data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B',","Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data #","data)) # Expected binary data: char (1 byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data))","# Field of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4))","data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int (4 bytes)","# Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data","struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data: float (4 bytes) data,","(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice center","f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along Y axis data, = struct.unpack('<f',","data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected","data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti","f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, =","f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data","data # Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"]","BV to Tal # Expected binary data: unsigned char (1 byte) data_img =","(header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal","(3 translation, 3 rotation, 3 scale) # \"2\": Affine transformation (16 values, 4x4","element (intensity value) is # represented in 1 byte. The data is organized","Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row direction","BrainVoyager's internal format. These four entries are followed by # scan position information","dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img,","np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR","# --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard data_img","Output filename. header : dictionary Header of VMR file. data_img : numpy.array, 3D","header. The current # version of VMR files is \"4\", which is only","data)) # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) #","# Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data","= header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data = header[\"DimZ\"] f.write(struct.pack('<H',","slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of","a version storing each intensity value with two bytes (short # integers). The","post-data header contains position information (if available) # and stores a series of","np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV","f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data: int (4 bytes) data, =","header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int","data)) # Expected binary data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data))","# --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned","variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int","2 in order to represent large data sets efficiently, e.g. in # the","advanced segmentation processing. Compared to the # original file version \"1\", file versions","data element (intensity value) is # represented in 1 byte. The data is","of subjects. The # intensity values are stored as a series of bytes.","data # 16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename,","2.6): For each past transformation, the # information specified in the following table","f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data","= data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2,","Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header : dictionary","f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary","and higher contain # additional header information after the actual data (\"post-data #","space # BV (Y top -> bottom) [axis 1 after np.reshape] = Z","labels in these entries are not in # terms of BrainVoyager's internal conventions","data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) # Expected binary","data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data =","# Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to","VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical","!= 0: # NOTE(Developer Guide 2.6): For each past transformation, the # information","unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i]))","coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center Z","thickness [mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))","if header[\"File version\"] >= 3: # Expected binary data: short int (2 bytes)","binary data: float (4 bytes) data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"]","data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data","which the data set will be internally \"expanded\" # for certain operations. The","convention, the reference space (e.g. Talairach after # normalization) and voxel resolution. if","i in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f,","header[\"PastTransformation\"] = [] for i in range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length","data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each","byte) data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected","header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values =","follows the internal BrainVoyager (BV) format. # The mapping to Talairach axes is","as a list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary","data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] = data # Slice column direction vector X","f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data = header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i',","assumed # left-right convention, the reference space (e.g. Talairach after # normalization) and","to read VMR data sets with minimal header # checking if the extended","(head) of subjects. The # intensity values are stored as a series of","header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data = header[\"VoxelSizeX\"]","= struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm] # Expected binary","First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data #","Store transformation values as a list trans_values = [] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]):","Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal","header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data))","# Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"ColDirY\"] =","(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of view","short int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"]","data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"]","# BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes","data followed by a second, more extensive, header. The current # version of","f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4","VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value)","e.g. in # the context of advanced segmentation processing. Compared to the #","This allows to read VMR data sets with minimal header # checking if","version \"3\" and contain offset values for # each dimension as well as","data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data:","# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] =","standard. Then follows eventually a section listing spatial # transformations which have been","data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) # Expected binary","data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"] >=","= struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- # VMR Data # ---------------------------------------------------------------------","struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice center Y coordinate data, =","\"5\": Un-Talairach transformation (1 - 5 -> BV axes) header[\"PastTransformation\"] = [] for","= struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4 # Expected binary","# version of VMR files is \"4\", which is only slightly different from","= data # Nr of rows of slice image matrix data, = struct.unpack('<i',","stored. The # \"type of transformation\" is a value determining how many #","data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] =","bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in","# ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename : string","[mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm] #","DimZ # DimY # DimX # # The axes terminology follows the internal","3 added offset values to # format 2 in order to represent large","data set, including the assumed # left-right convention, the reference space (e.g. Talairach","= data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"]","= data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] =","# and stores a series of spatial transformations, which might have been #","f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File version\"]","# Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"] =","stored as a series of bytes. See the V16 format # for a","by the # actual data followed by a second, more extensive, header. The","information # in the post-data header contains position information (if available) # and","by # scan position information from the original file headers, e.g. from #","[mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"]","data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char","data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] =","binary data: unsigned short int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data))","f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):","int (2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H',","range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\"File","slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First","header[\"PastTransformation\"][i][\"Values\"] = trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B',","v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"]","header[\"Slice1CenterY\"] f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data))","space # Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] *","X coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice center","version\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H',","in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))","f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"]","import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # =============================================================================","--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the post-data #","binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data #","= struct.unpack('<f', f.read(4)) header[\"SliceThickness\"] = data # Slice thickness [mm] data, = struct.unpack('<f',","header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data))","# checking if the extended information is not needed. The information # in","int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for","in Tal space # BV (Y top -> bottom) [axis 1 after np.reshape]","data, = struct.unpack('<f', f.read(4)) header[\"FoVCols\"] = data # Field of view extent in","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"NrOfValues\"] = data # Store transformation","data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of columns of slice","f.write(struct.pack('<f', data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data","for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\"DimZ\"],","data data, = struct.unpack('<h', f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"]","data # Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"]","= struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice center X coordinate data,","BrainVoyager's internal conventions but follow the DICOM # standard. Then follows eventually a","= data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"]","Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data","Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data","Finally, additional # information further descries the data set, including the assumed #","Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data","= header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"SourceFileName\"]","can be probably ignored for custom routines, but is # important in BrainVoyager","of transformation\" is a value determining how many # subsequent values define the","binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary","data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0: for i in range(header[\"NrOfPastSpatialTransformations\"]):","slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last","Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard","np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1]",": string Path to file. Returns ------- header : dictionary Pre-data and post-data","= data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))","struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm] # Expected binary data:","numpy.array Image data. \"\"\" header = dict() with open(filename, 'rb') as f: #","\"\"\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string Output filename.","# VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity","entries are not in # terms of BrainVoyager's internal conventions but follow the","# important in BrainVoyager QX for spatial transformation and # coregistration routines as","eventually a section listing spatial # transformations which have been eventually performed to","header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected binary data: int","data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary","header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H',","in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected","(1 byte) data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1))","binary data: short int (2 bytes) data = header[\"OffsetX\"] f.write(struct.pack('<h', data)) data =","# Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\"RowDirY\"] =","f.read(2)) header[\"OffsetY\"] = data data, = struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, =","int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data))","data = header[\"VoxelResolutionVerified\"] f.write(struct.pack('<B', data)) data = header[\"VoxelResolutionInTALmm\"] f.write(struct.pack('<B', data)) # Expected binary","of advanced segmentation processing. Compared to the # original file version \"1\", file","= np.reshape( data_img, (header[\"DimZ\"], header[\"DimY\"], header[\"DimX\"])) data_img = np.transpose(data_img, (0, 2, 1)) #","data can be probably ignored for custom routines, but is # important in","X in Tal space # Expected binary data: unsigned char (1 byte) data_img","Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"] = data # Slice column direction","coordinate axes labels in these entries are not in # terms of BrainVoyager's","data # Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\"ColDirX\"]","axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along Z","data # Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"ColDirZ\"]","of columns of slice image matrix # Expected binary data: float (4 bytes)","Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the","bytes) data, = struct.unpack('<i', f.read(4)) header[\"NRows\"] = data # Nr of rows of","f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"] f.write(struct.pack('<f', data)) #","with # iso-dimensions to which the data set will be internally \"expanded\" #","# typically containing the whole brain (head) of subjects. The # intensity values","second, more extensive, header. The current # version of VMR files is \"4\",","data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First","represented in 1 byte. The data is organized in three loops: # DimZ","# Expected binary data: int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data","# standard. Then follows eventually a section listing spatial # transformations which have","header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data))","three loops: # DimZ # DimY # DimX # # The axes terminology","(4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) #","from Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] #","data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) # Expected","data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte)","# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] =","data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeZ\"]","header[\"VoxelSizeY\"] = data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4))","(2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, = struct.unpack('<h', f.read(2))",": string Output filename. header : dictionary Header of VMR file. data_img :","v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"] = data # new in v4 #","data_img : numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as f: # ---------------------------------------------------------------------","in the following table is stored. The # \"type of transformation\" is a","data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data # Expected binary data: int (4","after np.reshape] = Z in Tal space # BV (Z left -> right)","= header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f',","direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice","Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center","= data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"]","routines as well as for proper visualization. # Expected binary data: unsigned short","file version \"1\", file versions 2 and higher contain # additional header information","a second, more extensive, header. The current # version of VMR files is","f.read(1)) header[\"VoxelResolutionVerified\"] = data data, = struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected","with two bytes (short # integers). The VMR format contains a small header","data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data #","data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field","= header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data = header[\"RowDirZ\"] f.write(struct.pack('<f',","= data # Store transformation values as a list trans_values = [] for","= header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert","header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',","data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes)","header[\"NRows\"] = data # Nr of rows of slice image matrix data, =","X axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along","header[\"SliceThickness\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] =","file versions 2 and higher contain # additional header information after the actual","of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr","data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"]","cube with # iso-dimensions to which the data set will be internally \"expanded\"","= struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity return header,","# header are new since file version \"3\" and contain offset values for","conventions but follow the DICOM # standard. Then follows eventually a section listing","data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0,","============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR file. Parameters ----------","data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"] = data # Expected binary data: float","data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel","f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data = header[\"PosInfosVerified\"] f.write(struct.pack('<i',","binary data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"]","Z component # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))","= data # Slice column direction vector X component data, = struct.unpack('<f', f.read(4))","char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i","Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeZ\"] = data #","have been eventually performed to create the # current VMR (e.g. ACPC transformation).","performed to the original data set (\"history record\"). The # post-header data can","(BV) format. # The mapping to Talairach axes is as follows: # BV","original file headers, e.g. from # DICOM files. The coordinate axes labels in","column direction vector Z component # Expected binary data: int (4 bytes) data,","binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] !=","binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary","to the original data set (\"history record\"). The # post-header data can be","Header # --------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected binary data: short","header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation, the #","int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data","f.read(2)) header[\"DimX\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimY\"] = data data, =","f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along X axis data, = struct.unpack('<f',","data)) data = header[\"SliceThickness\"] f.write(struct.pack('<f', data)) data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected","Talairach axes is as follows: # BV (X front -> back) [axis 2","# in the post-data header contains position information (if available) # and stores","data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row direction vector X","efficiently, e.g. in # the context of advanced segmentation processing. Compared to the","stores a series of spatial transformations, which might have been # performed to","\"\"\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to file. Returns","bytes) data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterX\"] = data # First slice center X","BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes #","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if header[\"NrOfPastSpatialTransformations\"] != 0:","(2 bytes) data = header[\"File version\"] f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data))","# VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four","Convert axes from Nifti standard back to BV standard data_img = data_img[::-1, ::-1,","the reference space (e.g. Talairach after # normalization) and voxel resolution. if header[\"File","binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data) # Expected binary data:","header[\"RowDirY\"] = data # Slice row direction vector Y component data, = struct.unpack('<f',","# Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for i","header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"]","# the context of advanced segmentation processing. Compared to the # original file","are not in # terms of BrainVoyager's internal conventions but follow the DICOM","Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data # Last slice center",">= 3: # NOTE(Developer Guide 2.6): These four entries have been added in","dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header #","byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected","data: float (4 bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f',","string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] = data # Expected binary data: int (4","# Nr of columns of slice image matrix # Expected binary data: float","VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV","range(header[\"NrOfPastSpatialTransformations\"]): header[\"PastTransformation\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"Name\"] =","(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along","struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def","# current VMR (e.g. ACPC transformation). Finally, additional # information further descries the","---------- filename : string Path to file. Returns ------- header : dictionary Pre-data","# Convert axes from Nifti standard back to BV standard data_img = data_img[::-1,","float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] = data # Field of","= struct.unpack('<f', f.read(4)) header[\"Slice1CenterZ\"] = data # First slice center Z coordinate data,","reference space (e.g. Talairach after # normalization) and voxel resolution. if header[\"File version\"]","data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data =","well as a value indicating the size of a cube with # iso-dimensions","Guide 2.6): VMR files contain anatomical 3D data sets, # typically containing the","Path to file. Returns ------- header : dictionary Pre-data and post-data headers. data","The axes labels are in terms of # BrainVoyager's internal format. These four","to file version \"2\". # Expected binary data: short int (2 bytes) data,","header information after the actual data (\"post-data # header\"). This allows to read","The mapping to Talairach axes is as follows: # BV (X front ->","# NOTE(Developer Guide 2.6): The first four entries of the post-data # header","a series of bytes. See the V16 format # for a version storing","# identical to file version \"2\". # Expected binary data: short int (2","version \"3\" with BrainVoyager QX 1.7. All other entries are # identical to","# Expected binary data: variable-length string data = read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data #","additional # information further descries the data set, including the assumed # left-right","f.read(2)) header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # ---------------------------------------------------------------------","data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max intensity return","current # version of VMR files is \"4\", which is only slightly different","# \"type of transformation\" is a value determining how many # subsequent values","np.reshape] = X in Tal space # Expected binary data: unsigned char (1","= data # Slice column direction vector Z component # Expected binary data:","byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size):","BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal #","numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read","16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MeanValue\"] = data # 16-bit","Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data","= dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header","information after the actual data (\"post-data # header\"). This allows to read VMR","header[\"SliceNCenterZ\"] = data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4))","in range(header[\"NrOfPastSpatialTransformations\"]): # Expected binary data: variable-length string data = header[\"PastTransformation\"][i][\"Name\"] write_variable_length_string(f, data)","subjects. The # intensity values are stored as a series of bytes. See","= header[\"PastTransformation\"][i][\"SourceFileName\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data =","f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\"ReferenceSpaceVMR\"]","bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a","axes terminology follows the internal BrainVoyager (BV) format. # The mapping to Talairach","# --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data =","from # DICOM files. The coordinate axes labels in these entries are not","data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data)) data =","First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterX\"] = data #","# Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\"GapThickness\"] = data # Gap","for custom routines, but is # important in BrainVoyager QX for spatial transformation","* header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1))","(1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for i in","as well as a value indicating the size of a cube with #","transformation, the # information specified in the following table is stored. The #","certain operations. The axes labels are in terms of # BrainVoyager's internal format.","(read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters ---------- filename","= struct.unpack('<f', f.read(4)) header[\"ColDirY\"] = data # Slice column direction vector Y component","= struct.unpack('<i', f.read(4)) header[\"NCols\"] = data # Nr of columns of slice image","the size of a cube with # iso-dimensions to which the data set","f.read(4)) header[\"VoxelSizeZ\"] = data # Voxel resolution along Z axis # Expected binary","struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center Z coordinate data, =","data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data)) if header[\"NrOfPastSpatialTransformations\"] != 0:","int (4 bytes) data = header[\"NRows\"] f.write(struct.pack('<i', data)) data = header[\"NCols\"] f.write(struct.pack('<i', data))","data set will be internally \"expanded\" # for certain operations. The axes labels","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"NrOfPastSpatialTransformations\"] = data if","header[\"Slice1CenterZ\"] = data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4))","data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] = trans_values #","center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\"RowDirX\"] = data # Slice row","data = header[\"FoVRows\"] f.write(struct.pack('<f', data)) data = header[\"FoVCols\"] f.write(struct.pack('<f', data)) data = header[\"SliceThickness\"]","data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"]","version\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have been added","a section listing spatial # transformations which have been eventually performed to create","data, = struct.unpack('<f', f.read(4)) header[\"Slice1CenterY\"] = data # First slice center Y coordinate","f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h', data)) data = header[\"FramingCubeDim\"] f.write(struct.pack('<h', data)) #","trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4","header[\"File version\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have been","X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] = data # Last slice center","data # new in v4 # Expected binary data: float (4 bytes) data,","binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data,","data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterY\"] =","transformation: # \"1\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \"2\":","# VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain","containing the whole brain (head) of subjects. The # intensity values are stored","(e.g. ACPC transformation). Finally, additional # information further descries the data set, including","BrainVoyager (BV) format. # The mapping to Talairach axes is as follows: #","\"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 - 5 -> BV axes)","if header[\"NrOfPastSpatialTransformations\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation, the","f.write(struct.pack('<H', data)) data = header[\"DimX\"] f.write(struct.pack('<H', data)) data = header[\"DimY\"] f.write(struct.pack('<H', data)) data","bytes) data = header[\"VoxelSizeX\"] f.write(struct.pack('<f', data)) data = header[\"VoxelSizeY\"] f.write(struct.pack('<f', data)) data =","header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data = header[\"RowDirX\"] f.write(struct.pack('<f', data)) data = header[\"RowDirY\"] f.write(struct.pack('<f', data))","data = header[\"GapThickness\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data","sets, # typically containing the whole brain (head) of subjects. The # intensity","visualization. # Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H',","= header[\"OffsetX\"] f.write(struct.pack('<h', data)) data = header[\"OffsetY\"] f.write(struct.pack('<h', data)) data = header[\"OffsetZ\"] f.write(struct.pack('<h',","f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data)) data = header[\"ColDirZ\"] f.write(struct.pack('<f', data)) #","data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list","indicating the size of a cube with # iso-dimensions to which the data","format. These four entries are followed by # scan position information from the","data)) # Expected binary data: int (4 bytes) data = header[\"NrOfPastSpatialTransformations\"] f.write(struct.pack('<i', data))","= header[\"PosInfosVerified\"] f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data:","data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header","f.read(4)) header[\"GapThickness\"] = data # Gap thickness [mm] # Expected binary data: int","and post-data headers. data : 3D numpy.array Image data. \"\"\" header = dict()","BrainVoyager QX for spatial transformation and # coregistration routines as well as for","data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR file.","Header of VMR file. data_img : numpy.array, 3D Image. \"\"\" with open(filename, 'wb')","unsigned char (1 byte) data_img = np.zeros((header[\"DimZ\"] * header[\"DimY\"] * header[\"DimX\"]), dtype=\"<B\") for","internal conventions but follow the DICOM # standard. Then follows eventually a section","data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"] f.write(struct.pack('<i', data)) return print(\"VMR saved.\")","terms of # BrainVoyager's internal format. These four entries are followed by #","follow the DICOM # standard. Then follows eventually a section listing spatial #","= struct.unpack('<h', f.read(2)) header[\"OffsetZ\"] = data data, = struct.unpack('<h', f.read(2)) header[\"FramingCubeDim\"] = data","data)) data = header[\"Slice1CenterZ\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterX\"] f.write(struct.pack('<f', data)) data =","the actual data (\"post-data # header\"). This allows to read VMR data sets","header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data = header[\"ReferenceSpaceVMR\"] f.write(struct.pack('<B', data)) # Expected binary data: float","Talairach after # normalization) and voxel resolution. if header[\"File version\"] >= 3: #","struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row direction vector Z component data,","data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeX\"] = data # Voxel resolution along X axis","Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data","descries the data set, including the assumed # left-right convention, the reference space","# file version \"3\" with BrainVoyager QX 1.7. All other entries are #","Z in Tal space # BV (Z left -> right) [axis 0 after","# --------------------------------------------------------------------- if header[\"File version\"] >= 3: # Expected binary data: short int","Then follows eventually a section listing spatial # transformations which have been eventually","of VMR file. data_img : numpy.array, 3D Image. \"\"\" with open(filename, 'wb') as","two bytes (short # integers). The VMR format contains a small header followed","to the # original file version \"1\", file versions 2 and higher contain","f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center Z coordinate data, = struct.unpack('<f',","small header followed by the # actual data followed by a second, more","operations. The axes labels are in terms of # BrainVoyager's internal format. These","import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename):","listing spatial # transformations which have been eventually performed to create the #","follows: # BV (X front -> back) [axis 2 after np.reshape] = Y","terminology follows the internal BrainVoyager (BV) format. # The mapping to Talairach axes","# Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- #","header[\"ColDirY\"] = data # Slice column direction vector Y component data, = struct.unpack('<f',","transformation and # coregistration routines as well as for proper visualization. # Expected","header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to write Brainvoyager VMR","offset values for # each dimension as well as a value indicating the","header[\"DimZ\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes","data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data","Guide 2.6): These four entries have been added in # file version \"3\"","Transformation values are stored as a list trans_values = header[\"PastTransformation\"][i][\"Values\"] for j in","header[\"DimY\"] = data data, = struct.unpack('<H', f.read(2)) header[\"DimZ\"] = data # --------------------------------------------------------------------- #","All other entries are # identical to file version \"2\". # Expected binary","data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data)) # Expected binary data:","data # Field of view extent in column dir. [mm] data, = struct.unpack('<f',","left -> right) [axis 0 after np.reshape] = X in Tal space #","= data # Nr of columns of slice image matrix # Expected binary","header[\"RowDirZ\"] f.write(struct.pack('<f', data)) data = header[\"ColDirX\"] f.write(struct.pack('<f', data)) data = header[\"ColDirY\"] f.write(struct.pack('<f', data))","(1 byte) data, = struct.unpack('<B', f.read(1)) header[\"LeftRightConvention\"] = data # modified in v4","data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"]","binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data","# iso-dimensions to which the data set will be internally \"expanded\" # for","data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length string","in terms of # BrainVoyager's internal format. These four entries are followed by","read_variable_length_string(f) header[\"PastTransformation\"][i][\"SourceFileName\"] = data # Expected binary data: int (4 bytes) data, =","axis data, = struct.unpack('<f', f.read(4)) header[\"VoxelSizeY\"] = data # Voxel resolution along Y","max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \"\"\"Protocol to","transformation\" is a value determining how many # subsequent values define the transformation:","= struct.unpack('<B', f.read(1)) header[\"VoxelResolutionInTALmm\"] = data # Expected binary data: int (4 bytes)","the whole brain (head) of subjects. The # intensity values are stored as","BrainVoyager QX 1.7. All other entries are # identical to file version \"2\".","bytes) data, = struct.unpack('<i', f.read(4)) header[\"PosInfosVerified\"] = data data, = struct.unpack('<i', f.read(4)) header[\"CoordinateSystem\"]","f.read(4)) header[\"NRows\"] = data # Nr of rows of slice image matrix data,","# Expected binary data: float (4 bytes) data = header[\"Slice1CenterX\"] f.write(struct.pack('<f', data)) data","only slightly different from # version 3 (as indicated below). Version 3 added","bytes) data, = struct.unpack('<i', f.read(4)) header[\"PastTransformation\"][i][\"Type\"] = data # Expected binary data: variable-length","# post-header data can be probably ignored for custom routines, but is #","Y coordinate data, = struct.unpack('<f', f.read(4)) header[\"SliceNCenterZ\"] = data # Last slice center","files is \"4\", which is only slightly different from # version 3 (as","Expected binary data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data)) data =","write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"NrOfValues\"] f.write(struct.pack('<i',","bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \"\"\"Read Brainvoyager VMR file. Parameters","data) # Expected binary data: int (4 bytes) data = header[\"PastTransformation\"][i][\"Type\"] f.write(struct.pack('<i', data))","Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\"PastTransformation\"][i][\"Values\"] =","image matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))","::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) #","in # terms of BrainVoyager's internal conventions but follow the DICOM # standard.","3: # NOTE(Developer Guide 2.6): These four entries have been added in #","short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\"OffsetX\"] = data data, =","= data # Voxel resolution along Z axis # Expected binary data: char","along Z axis # Expected binary data: char (1 byte) data, = struct.unpack('<B',","\"1\", file versions 2 and higher contain # additional header information after the","(e.g. Talairach after # normalization) and voxel resolution. if header[\"File version\"] >= 3:","QX for spatial transformation and # coregistration routines as well as for proper","to # format 2 in order to represent large data sets efficiently, e.g.","Y component data, = struct.unpack('<f', f.read(4)) header[\"RowDirZ\"] = data # Slice row direction","(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MinValue\"] = data # 16-bit data min","f.read(4)) header[\"RowDirZ\"] = data # Slice row direction vector Z component data, =","f.write(struct.pack('<i', data)) data = header[\"CoordinateSystem\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4","f.write(struct.pack('<f', data)) data = header[\"SliceNCenterY\"] f.write(struct.pack('<f', data)) data = header[\"SliceNCenterZ\"] f.write(struct.pack('<f', data)) data","Slice column direction vector Z component # Expected binary data: int (4 bytes)","to represent large data sets efficiently, e.g. in # the context of advanced","proper visualization. # Expected binary data: unsigned short int (2 bytes) data, =","NOTE(Developer Guide 2.6): These four entries have been added in # file version","axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):","= header[\"VMROrigV16MinValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MeanValue\"] f.write(struct.pack('<i', data)) data = header[\"VMROrigV16MaxValue\"] f.write(struct.pack('<i',","header[\"FoVCols\"] = data # Field of view extent in column dir. [mm] data,","[] for j in range(header[\"PastTransformation\"][i][\"NrOfValues\"]): # Expected binary data: float (4 bytes) data,","axes from Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1]","(0, 2, 1)) # BV to Tal # Expected binary data: unsigned char","trans_values[j])) # Expected binary data: char (1 byte) data = header[\"LeftRightConvention\"] f.write(struct.pack('<B', data))","# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\"FoVRows\"] =","= data # new in v4 # Expected binary data: float (4 bytes)"],"string":"[\n \"matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 - 5 ->\",\n \"order to represent large data sets efficiently, e.g. in # the context of\",\n \"mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max\",\n \"header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h',\",\n \"Compared to the # original file version \\\"1\\\", file versions 2 and higher\",\n \"header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"]\",\n \"value) is # represented in 1 byte. The data is organized in three\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] !=\",\n \"The current # version of VMR files is \\\"4\\\", which is only slightly\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] =\",\n \"intensity values are stored as a series of bytes. See the V16 format\",\n \"data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data\",\n \"f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4))\",\n \"file format.\\\"\\\"\\\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string)\",\n \"VMR data sets with minimal header # checking if the extended information is\",\n \"= data # Slice row direction vector X component data, = struct.unpack('<f', f.read(4))\",\n \"the internal BrainVoyager (BV) format. # The mapping to Talairach axes is as\",\n \"(4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data =\",\n \"intensity value with two bytes (short # integers). The VMR format contains a\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store\",\n \"Voxel resolution along Z axis # Expected binary data: char (1 byte) data,\",\n \"data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"]\",\n \"= header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data:\",\n \"below). Version 3 added offset values to # format 2 in order to\",\n \"in BrainVoyager QX for spatial transformation and # coregistration routines as well as\",\n \"= np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], =\",\n \"actual data followed by a second, more extensive, header. The current # version\",\n \"binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary\",\n \"is not needed. The information # in the post-data header contains position information\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction vector\",\n \"component # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"]\",\n \"data is organized in three loops: # DimZ # DimY # DimX #\",\n \"file version \\\"2\\\". # Expected binary data: short int (2 bytes) data, =\",\n \"each dimension as well as a value indicating the size of a cube\",\n \"BV (Y top -> bottom) [axis 1 after np.reshape] = Z in Tal\",\n \"in the post-data header contains position information (if available) # and stores a\",\n \"for # each dimension as well as a value indicating the size of\",\n \"# Transformation values are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j\",\n \"0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data =\",\n \"(Z left -> right) [axis 0 after np.reshape] = X in Tal space\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data #\",\n \"# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is #\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y axis data,\",\n \"in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice\",\n \"Affine transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach\",\n \"NOTE(Developer Guide 2.6): The first four entries of the post-data # header are\",\n \"data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data\",\n \"# left-right convention, the reference space (e.g. Talairach after # normalization) and voxel\",\n \"= read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int (4 bytes) data,\",\n \"Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] =\",\n \"= data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):\",\n \"data)) # Expected binary data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data))\",\n \"axes labels in these entries are not in # terms of BrainVoyager's internal\",\n \"values are stored as a series of bytes. See the V16 format #\",\n \"f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from\",\n \"struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows of slice image matrix\",\n \"VMR (e.g. ACPC transformation). Finally, additional # information further descries the data set,\",\n \"= [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes)\",\n \"after np.reshape] = X in Tal space # Expected binary data: unsigned char\",\n \"Version 3 added offset values to # format 2 in order to represent\",\n \"f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B',\",\n \"(4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data\",\n \"many # subsequent values define the transformation: # \\\"1\\\": Rigid body+scale (3 translation,\",\n \"# First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data\",\n \"Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data\",\n \"header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int\",\n \"position information from the original file headers, e.g. from # DICOM files. The\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction vector Z component\",\n \"header followed by the # actual data followed by a second, more extensive,\",\n \"# Field of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4))\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: #\",\n \"of slice image matrix # Expected binary data: float (4 bytes) data, =\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data\",\n \"four entries have been added in # file version \\\"3\\\" with BrainVoyager QX\",\n \"to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img\",\n \"column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness\",\n \"--------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected binary data: short int (2\",\n \"not in # terms of BrainVoyager's internal conventions but follow the DICOM #\",\n \"= header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data =\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit\",\n \"is only slightly different from # version 3 (as indicated below). Version 3\",\n \"data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data #\",\n \"--------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: #\",\n \"--------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard data_img =\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data\",\n \"axes labels are in terms of # BrainVoyager's internal format. These four entries\",\n \"= header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f',\",\n \"# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] =\",\n \"header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view extent in column\",\n \"data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes)\",\n \"version\\\"] >= 3: # Expected binary data: short int (2 bytes) data =\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f',\",\n \"Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"]\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center Y coordinate data,\",\n \"data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes)\",\n \"= data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] =\",\n \"bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data =\",\n \"[axis 1 after np.reshape] = Z in Tal space # BV (Z left\",\n \"contain anatomical 3D data sets, # typically containing the whole brain (head) of\",\n \"set, including the assumed # left-right convention, the reference space (e.g. Talairach after\",\n \"--------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files\",\n \"# coregistration routines as well as for proper visualization. # Expected binary data:\",\n \"X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction\",\n \"The # \\\"type of transformation\\\" is a value determining how many # subsequent\",\n \"Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation\",\n \"to create the # current VMR (e.g. ACPC transformation). Finally, additional # information\",\n \"(4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data\",\n \"transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for i in\",\n \"header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char\",\n \"actual data (\\\"post-data # header\\\"). This allows to read VMR data sets with\",\n \"the post-data header contains position information (if available) # and stores a series\",\n \"slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z axis #\",\n \"data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"]\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i',\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center X coordinate\",\n \"# Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data #\",\n \"::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # ---------------------------------------------------------------------\",\n \"data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int\",\n \"intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity\",\n \"standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV\",\n \"# Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data\",\n \"Tal space # BV (Z left -> right) [axis 0 after np.reshape] =\",\n \"data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i',\",\n \"loops: # DimZ # DimY # DimX # # The axes terminology follows\",\n \"added in # file version \\\"3\\\" with BrainVoyager QX 1.7. All other entries\",\n \"= data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2))\",\n \"1)) # BV to Tal # Expected binary data: unsigned char (1 byte)\",\n \"Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- #\",\n \"resolution along Z axis # Expected binary data: char (1 byte) data, =\",\n \"\\\"2\\\". # Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2))\",\n \"version of VMR files is \\\"4\\\", which is only slightly different from #\",\n \"large data sets efficiently, e.g. in # the context of advanced segmentation processing.\",\n \"Guide 2.6): The first four entries of the post-data # header are new\",\n \"struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center X coordinate data, =\",\n \"BV (X front -> back) [axis 2 after np.reshape] = Y in Tal\",\n \"# integers). The VMR format contains a small header followed by the #\",\n \"Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data #\",\n \"f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction vector X component data, =\",\n \"= header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f',\",\n \"Gap thickness [mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] =\",\n \"voxel resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6): These four\",\n \"the # actual data followed by a second, more extensive, header. The current\",\n \"# Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] =\",\n \"DICOM # standard. Then follows eventually a section listing spatial # transformations which\",\n \"= data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data\",\n \"= header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data =\",\n \"f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data #\",\n \"data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"]\",\n \"set will be internally \\\"expanded\\\" # for certain operations. The axes labels are\",\n \"= struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] =\",\n \"read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int (4 bytes) data, =\",\n \"= header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f',\",\n \"with BrainVoyager QX 1.7. All other entries are # identical to file version\",\n \"header[\\\"GapThickness\\\"] = data # Gap thickness [mm] # Expected binary data: int (4\",\n \"header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img\",\n \"struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center Y coordinate data, =\",\n \"= data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"]\",\n \"data # Slice column direction vector Z component # Expected binary data: int\",\n \"intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity\",\n \"data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"]\",\n \"numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR\",\n \"e.g. from # DICOM files. The coordinate axes labels in these entries are\",\n \"space # BV (Z left -> right) [axis 0 after np.reshape] = X\",\n \"1 byte. The data is organized in three loops: # DimZ # DimY\",\n \"float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data\",\n \"data: short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"]\",\n \"slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice\",\n \"which have been eventually performed to create the # current VMR (e.g. ACPC\",\n \"eventually performed to create the # current VMR (e.g. ACPC transformation). Finally, additional\",\n \"Expected binary data: short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data\",\n \"format # for a version storing each intensity value with two bytes (short\",\n \"First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data #\",\n \"header contains position information (if available) # and stores a series of spatial\",\n \"f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4\",\n \"series of spatial transformations, which might have been # performed to the original\",\n \"binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data #\",\n \"--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, #\",\n \"# First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data\",\n \"2 and higher contain # additional header information after the actual data (\\\"post-data\",\n \"char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B',\",\n \"\\\"\\\"\\\"Read, write, create Brainvoyager VMR file format.\\\"\\\"\\\" import struct import numpy as np\",\n \"Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction\",\n \"data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int (4\",\n \"struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z axis # Expected\",\n \"= header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data:\",\n \"data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img =\",\n \"right) [axis 0 after np.reshape] = X in Tal space # Expected binary\",\n \"the transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3 scale) #\",\n \"trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4\",\n \"# DimX # # The axes terminology follows the internal BrainVoyager (BV) format.\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z axis\",\n \"read VMR data sets with minimal header # checking if the extended information\",\n \"= header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data:\",\n \"= header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f',\",\n \"int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored\",\n \"Expected binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data =\",\n \"the # information specified in the following table is stored. The # \\\"type\",\n \"coregistration routines as well as for proper visualization. # Expected binary data: unsigned\",\n \"of # BrainVoyager's internal format. These four entries are followed by # scan\",\n \"Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data\",\n \"of VMR files is \\\"4\\\", which is only slightly different from # version\",\n \"# Expected binary data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data\",\n \"struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction vector X component data,\",\n \"top -> bottom) [axis 1 after np.reshape] = Z in Tal space #\",\n \"- 5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict())\",\n \"direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view\",\n \"Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data\",\n \": numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- #\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data\",\n \"The data is organized in three loops: # DimZ # DimY # DimX\",\n \"version \\\"1\\\", file versions 2 and higher contain # additional header information after\",\n \"after the actual data (\\\"post-data # header\\\"). This allows to read VMR data\",\n \"as follows: # BV (X front -> back) [axis 2 after np.reshape] =\",\n \"Rigid body+scale (3 translation, 3 rotation, 3 scale) # \\\"2\\\": Affine transformation (16\",\n \"direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice\",\n \"VMR files contain anatomical 3D data sets, # typically containing the whole brain\",\n \"# # The axes terminology follows the internal BrainVoyager (BV) format. # The\",\n \"def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to\",\n \"dimension as well as a value indicating the size of a cube with\",\n \"header are new since file version \\\"3\\\" and contain offset values for #\",\n \"0 after np.reshape] = X in Tal space # Expected binary data: unsigned\",\n \"= struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char (1\",\n \"entries are followed by # scan position information from the original file headers,\",\n \"data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- #\",\n \"a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data:\",\n \"header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string\",\n \"# ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center Y\",\n \"struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data #\",\n \"# additional header information after the actual data (\\\"post-data # header\\\"). This allows\",\n \"header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\\\"FoVRows\\\"]\",\n \"body+scale (3 translation, 3 rotation, 3 scale) # \\\"2\\\": Affine transformation (16 values,\",\n \"Field of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"]\",\n \"============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path\",\n \"# actual data followed by a second, more extensive, header. The current #\",\n \"VMR files is \\\"4\\\", which is only slightly different from # version 3\",\n \"binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"]\",\n \"unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data\",\n \"of a cube with # iso-dimensions to which the data set will be\",\n \"bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected\",\n \"= header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data =\",\n \"four entries of the post-data # header are new since file version \\\"3\\\"\",\n \"# First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data\",\n \"# --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The\",\n \"# NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented in\",\n \"--------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short\",\n \"column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data #\",\n \"thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm]\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center X coordinate\",\n \"after # normalization) and voxel resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer\",\n \"values as a list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected\",\n \"data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] =\",\n \"data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] =\",\n \"row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data #\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer\",\n \"# terms of BrainVoyager's internal conventions but follow the DICOM # standard. Then\",\n \"files contain anatomical 3D data sets, # typically containing the whole brain (head)\",\n \"is as follows: # BV (X front -> back) [axis 2 after np.reshape]\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] =\",\n \"header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string\",\n \"float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data))\",\n \"3 rotation, 3 scale) # \\\"2\\\": Affine transformation (16 values, 4x4 matrix) #\",\n \"bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected\",\n \"= trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1))\",\n \"format 2 in order to represent large data sets efficiently, e.g. in #\",\n \"These four entries are followed by # scan position information from the original\",\n \"checking if the extended information is not needed. The information # in the\",\n \"center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice\",\n \"Parameters ---------- filename : string Path to file. Returns ------- header : dictionary\",\n \"Un-Talairach transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for i\",\n \"(4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary\",\n \"segmentation processing. Compared to the # original file version \\\"1\\\", file versions 2\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data #\",\n \"header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data))\",\n \"Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data #\",\n \"data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes)\",\n \"data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data\",\n \"header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z axis # Expected binary data:\",\n \"f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float (4 bytes) data, =\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float (4 bytes)\",\n \"\\\"4\\\", which is only slightly different from # version 3 (as indicated below).\",\n \"brain (head) of subjects. The # intensity values are stored as a series\",\n \"data set (\\\"history record\\\"). The # post-header data can be probably ignored for\",\n \"header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"the V16 format # for a version storing each intensity value with two\",\n \"new in v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f',\",\n \"data)) # Transformation values are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction vector Z component\",\n \"f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center Y coordinate data, = struct.unpack('<f',\",\n \"modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in\",\n \"have been added in # file version \\\"3\\\" with BrainVoyager QX 1.7. All\",\n \"\\\"2\\\": Affine transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\":\",\n \"data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte)\",\n \"# normalization) and voxel resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide\",\n \"# Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"]\",\n \"# Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center X coordinate data,\",\n \"(16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1\",\n \"the # current VMR (e.g. ACPC transformation). Finally, additional # information further descries\",\n \"further descries the data set, including the assumed # left-right convention, the reference\",\n \"f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int (4 bytes) data, =\",\n \"data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"]\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center Z coordinate\",\n \"to which the data set will be internally \\\"expanded\\\" # for certain operations.\",\n \"to Tal # Expected binary data: unsigned char (1 byte) data_img = data_img.flatten()\",\n \"the post-data # header are new since file version \\\"3\\\" and contain offset\",\n \"in three loops: # DimZ # DimY # DimX # # The axes\",\n \"might have been # performed to the original data set (\\\"history record\\\"). The\",\n \"view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data\",\n \"(2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H',\",\n \"of view extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] =\",\n \"original file version \\\"1\\\", file versions 2 and higher contain # additional header\",\n \"data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data\",\n \"along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows\",\n \"anatomical 3D data sets, # typically containing the whole brain (head) of subjects.\",\n \"# NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, # typically\",\n \"-> BV axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected\",\n \"header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img\",\n \"2.6): The first four entries of the post-data # header are new since\",\n \"transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation\",\n \"binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"]\",\n \"# --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3:\",\n \"(1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # ---------------------------------------------------------------------\",\n \"represent large data sets efficiently, e.g. in # the context of advanced segmentation\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data\",\n \"custom routines, but is # important in BrainVoyager QX for spatial transformation and\",\n \"f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f',\",\n \"header # checking if the extended information is not needed. The information #\",\n \"header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as a\",\n \"# VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int\",\n \"data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"]\",\n \"if the extended information is not needed. The information # in the post-data\",\n \"header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data))\",\n \"header : dictionary Header of VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\"\",\n \"these entries are not in # terms of BrainVoyager's internal conventions but follow\",\n \"data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i',\",\n \"f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns of slice image matrix #\",\n \"# performed to the original data set (\\\"history record\\\"). The # post-header data\",\n \"in Tal space # BV (Z left -> right) [axis 0 after np.reshape]\",\n \"matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns of\",\n \"for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) data, =\",\n \"Nr of columns of slice image matrix # Expected binary data: float (4\",\n \"data # Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4))\",\n \"4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 - 5\",\n \"---------- filename : string Output filename. header : dictionary Header of VMR file.\",\n \"= data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"]\",\n \"write, create Brainvoyager VMR file format.\\\"\\\"\\\" import struct import numpy as np from\",\n \"(if available) # and stores a series of spatial transformations, which might have\",\n \"data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are\",\n \"values define the transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) #\",\n \"f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected\",\n \"back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes\",\n \"-> bottom) [axis 1 after np.reshape] = Z in Tal space # BV\",\n \"data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"]\",\n \"axes is as follows: # BV (X front -> back) [axis 2 after\",\n \"data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"]\",\n \"entries of the post-data # header are new since file version \\\"3\\\" and\",\n \"-> back) [axis 2 after np.reshape] = Y in Tal space # BV\",\n \"in order to represent large data sets efficiently, e.g. in # the context\",\n \"3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data\",\n \"data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1))\",\n \"Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] *\",\n \"different from # version 3 (as indicated below). Version 3 added offset values\",\n \"file headers, e.g. from # DICOM files. The coordinate axes labels in these\",\n \"f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4\",\n \"data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f',\",\n \"scale) # \\\"2\\\": Affine transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation\",\n \"version storing each intensity value with two bytes (short # integers). The VMR\",\n \"to file. Returns ------- header : dictionary Pre-data and post-data headers. data :\",\n \"(\\\"post-data # header\\\"). This allows to read VMR data sets with minimal header\",\n \"char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) #\",\n \"transformations which have been eventually performed to create the # current VMR (e.g.\",\n \"image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns\",\n \"struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data,\",\n \"f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as a list trans_values =\",\n \"are new since file version \\\"3\\\" and contain offset values for # each\",\n \"bytes. See the V16 format # for a version storing each intensity value\",\n \"internal format. These four entries are followed by # scan position information from\",\n \"important in BrainVoyager QX for spatial transformation and # coregistration routines as well\",\n \"data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4 data, =\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f,\",\n \"will be internally \\\"expanded\\\" # for certain operations. The axes labels are in\",\n \"DimY # DimX # # The axes terminology follows the internal BrainVoyager (BV)\",\n \"header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float\",\n \"# \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 - 5 -> BV\",\n \"as for proper visualization. # Expected binary data: unsigned short int (2 bytes)\",\n \"f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4))\",\n \"scan position information from the original file headers, e.g. from # DICOM files.\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction vector X component\",\n \"dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm]\",\n \"= data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] =\",\n \"QX 1.7. All other entries are # identical to file version \\\"2\\\". #\",\n \"float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected\",\n \"format.\\\"\\\"\\\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) #\",\n \"allows to read VMR data sets with minimal header # checking if the\",\n \"minimal header # checking if the extended information is not needed. The information\",\n \"data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string Output\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction vector Y component\",\n \"stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected\",\n \"from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file.\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction vector Y\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z\",\n \"write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i',\",\n \"data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary\",\n \"struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data #\",\n \"data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data =\",\n \"# Expected binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data\",\n \"# Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected\",\n \"size of a cube with # iso-dimensions to which the data set will\",\n \"V16 format # for a version storing each intensity value with two bytes\",\n \"= header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes)\",\n \"organized in three loops: # DimZ # DimY # DimX # # The\",\n \"component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction vector\",\n \"struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char (1 byte)\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) #\",\n \"which is only slightly different from # version 3 (as indicated below). Version\",\n \"f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity return header, data_img #\",\n \"header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 # Expected binary data: float (4\",\n \"header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, =\",\n \"entries have been added in # file version \\\"3\\\" with BrainVoyager QX 1.7.\",\n \"header[\\\"Slice1CenterX\\\"] = data # First slice center X coordinate data, = struct.unpack('<f', f.read(4))\",\n \"columns of slice image matrix # Expected binary data: float (4 bytes) data,\",\n \"values are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]):\",\n \"header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape(\",\n \"# BV (X front -> back) [axis 2 after np.reshape] = Y in\",\n \"center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice\",\n \"# --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data\",\n \"as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary\",\n \"contains position information (if available) # and stores a series of spatial transformations,\",\n \"added offset values to # format 2 in order to represent large data\",\n \"data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] =\",\n \"# VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to\",\n \"--------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element\",\n \"including the assumed # left-right convention, the reference space (e.g. Talairach after #\",\n \"data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data =\",\n \"[mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data,\",\n \"data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] =\",\n \"# scan position information from the original file headers, e.g. from # DICOM\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"]\",\n \"(4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string\",\n \"data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]\",\n \"(X front -> back) [axis 2 after np.reshape] = Y in Tal space\",\n \"filename : string Output filename. header : dictionary Header of VMR file. data_img\",\n \"bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X\",\n \"data # Store transformation values as a list trans_values = [] for j\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length string data\",\n \"--------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data = header[\\\"File\",\n \"struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4))\",\n \"four entries are followed by # scan position information from the original file\",\n \"(4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data\",\n \"axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data:\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] =\",\n \"data: unsigned short int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data\",\n \"3 (as indicated below). Version 3 added offset values to # format 2\",\n \"# Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] =\",\n \"value with two bytes (short # integers). The VMR format contains a small\",\n \"post-header data can be probably ignored for custom routines, but is # important\",\n \"# format 2 in order to represent large data sets efficiently, e.g. in\",\n \"are in terms of # BrainVoyager's internal format. These four entries are followed\",\n \"= struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data\",\n \"DICOM files. The coordinate axes labels in these entries are not in #\",\n \"# The mapping to Talairach axes is as follows: # BV (X front\",\n \"f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center X coordinate data, = struct.unpack('<f',\",\n \"------- header : dictionary Pre-data and post-data headers. data : 3D numpy.array Image\",\n \"binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"]\",\n \"# BV (Z left -> right) [axis 0 after np.reshape] = X in\",\n \"with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # ---------------------------------------------------------------------\",\n \"struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int (4 bytes) data,\",\n \"header : dictionary Pre-data and post-data headers. data : 3D numpy.array Image data.\",\n \"have been # performed to the original data set (\\\"history record\\\"). The #\",\n \"= struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, =\",\n \"contain # additional header information after the actual data (\\\"post-data # header\\\"). This\",\n \"3: # Expected binary data: short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h',\",\n \"data sets efficiently, e.g. in # the context of advanced segmentation processing. Compared\",\n \"been eventually performed to create the # current VMR (e.g. ACPC transformation). Finally,\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as\",\n \"axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected\",\n \"the DICOM # standard. Then follows eventually a section listing spatial # transformations\",\n \"= struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data\",\n \"whole brain (head) of subjects. The # intensity values are stored as a\",\n \"Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data #\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] =\",\n \"bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data =\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary\",\n \"data. \\\"\\\"\\\" header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- #\",\n \"= header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"]\",\n \"(intensity value) is # represented in 1 byte. The data is organized in\",\n \"= data # Slice column direction vector Y component data, = struct.unpack('<f', f.read(4))\",\n \"write Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header :\",\n \"Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data\",\n \"dictionary Pre-data and post-data headers. data : 3D numpy.array Image data. \\\"\\\"\\\" header\",\n \"of bytes. See the V16 format # for a version storing each intensity\",\n \"f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f',\",\n \"struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data #\",\n \"f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data,\",\n \"struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data #\",\n \"binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"]\",\n \"header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data))\",\n \"struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center Z coordinate data, =\",\n \"for certain operations. The axes labels are in terms of # BrainVoyager's internal\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z coordinate data,\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data\",\n \"resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6): These four entries\",\n \"information from the original file headers, e.g. from # DICOM files. The coordinate\",\n \"header[\\\"RowDirX\\\"] = data # Slice row direction vector X component data, = struct.unpack('<f',\",\n \"= data # Slice row direction vector Z component data, = struct.unpack('<f', f.read(4))\",\n \"each past transformation, the # information specified in the following table is stored.\",\n \"terms of BrainVoyager's internal conventions but follow the DICOM # standard. Then follows\",\n \"The # post-header data can be probably ignored for custom routines, but is\",\n \"(0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] #\",\n \"rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data #\",\n \"header[\\\"SliceNCenterX\\\"] = data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4))\",\n \"# transformations which have been eventually performed to create the # current VMR\",\n \"(4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data\",\n \"1 after np.reshape] = Z in Tal space # BV (Z left ->\",\n \"data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f',\",\n \"The first four entries of the post-data # header are new since file\",\n \"dictionary Header of VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename,\",\n \"binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"]\",\n \"# 16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header,\",\n \"VMR format contains a small header followed by the # actual data followed\",\n \"row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data #\",\n \"\\\"3\\\" with BrainVoyager QX 1.7. All other entries are # identical to file\",\n \"vector Z component # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"# Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] =\",\n \"= np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary data:\",\n \"data # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"]\",\n \"Expected binary data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data =\",\n \"filename. header : dictionary Header of VMR file. data_img : numpy.array, 3D Image.\",\n \"f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i',\",\n \"in # the context of advanced segmentation processing. Compared to the # original\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data #\",\n \"typically containing the whole brain (head) of subjects. The # intensity values are\",\n \"f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view extent in row direction [mm]\",\n \"for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j]))\",\n \"data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data =\",\n \"data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z coordinate\",\n \"min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean\",\n \"= header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data =\",\n \"f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data\",\n \"# Nr of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"]\",\n \"struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data,\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction vector Y\",\n \"filename : string Path to file. Returns ------- header : dictionary Pre-data and\",\n \"variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int (4\",\n \"= data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data:\",\n \"f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view extent in column dir. [mm]\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data\",\n \"struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6):\",\n \"and stores a series of spatial transformations, which might have been # performed\",\n \"vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row\",\n \"followed by a second, more extensive, header. The current # version of VMR\",\n \"component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction vector\",\n \"Guide 2.6): For each past transformation, the # information specified in the following\",\n \"Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D\",\n \"(1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]):\",\n \"# 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data #\",\n \"# intensity values are stored as a series of bytes. See the V16\",\n \"header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h',\",\n \"data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes)\",\n \"= header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f',\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data:\",\n \"= data # Slice row direction vector Y component data, = struct.unpack('<f', f.read(4))\",\n \"binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"]\",\n \"data : 3D numpy.array Image data. \\\"\\\"\\\" header = dict() with open(filename, 'rb')\",\n \"for proper visualization. # Expected binary data: unsigned short int (2 bytes) data,\",\n \"char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data))\",\n \"Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected\",\n \"are stored as a series of bytes. See the V16 format # for\",\n \"slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last\",\n \"= header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR\",\n \"int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length\",\n \"VMR file format.\\\"\\\"\\\" import struct import numpy as np from bvbabel.utils import (read_variable_length_string,\",\n \"data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data,\",\n \"'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected\",\n \"variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int\",\n \"data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data\",\n \"!= 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data\",\n \"# Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data:\",\n \"create Brainvoyager VMR file format.\\\"\\\"\\\" import struct import numpy as np from bvbabel.utils\",\n \"X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction\",\n \"data # Nr of columns of slice image matrix # Expected binary data:\",\n \"[mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view extent\",\n \"i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f)\",\n \"These four entries have been added in # file version \\\"3\\\" with BrainVoyager\",\n \"data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary\",\n \"f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction vector Y component data, =\",\n \"= data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For each past\",\n \"* header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img =\",\n \"as well as for proper visualization. # Expected binary data: unsigned short int\",\n \"data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary\",\n \"data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int\",\n \"vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) #\",\n \"f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length string data = read_variable_length_string(f)\",\n \"Brainvoyager VMR file format.\\\"\\\"\\\" import struct import numpy as np from bvbabel.utils import\",\n \"values for # each dimension as well as a value indicating the size\",\n \"NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets, # typically containing\",\n \"follows eventually a section listing spatial # transformations which have been eventually performed\",\n \"version \\\"2\\\". # Expected binary data: short int (2 bytes) data, = struct.unpack('<h',\",\n \"binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data #\",\n \"data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes)\",\n \"data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr\",\n \"DimX # # The axes terminology follows the internal BrainVoyager (BV) format. #\",\n \"struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length string data =\",\n \"1.7. All other entries are # identical to file version \\\"2\\\". # Expected\",\n \"Expected binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data =\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data\",\n \"resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel\",\n \"bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data\",\n \"f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 # Expected binary data: float\",\n \"be probably ignored for custom routines, but is # important in BrainVoyager QX\",\n \"data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] =\",\n \"= read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int (4 bytes) data,\",\n \"f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4\",\n \"data (\\\"post-data # header\\\"). This allows to read VMR data sets with minimal\",\n \"data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes)\",\n \"struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data,\",\n \"np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary data: unsigned\",\n \"= header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data:\",\n \"'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as a list\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center Y coordinate\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction vector X component\",\n \"Image. \\\"\\\"\\\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity data,\",\n \"= [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string\",\n \"new since file version \\\"3\\\" and contain offset values for # each dimension\",\n \"data # Voxel resolution along Z axis # Expected binary data: char (1\",\n \"in these entries are not in # terms of BrainVoyager's internal conventions but\",\n \"space (e.g. Talairach after # normalization) and voxel resolution. if header[\\\"File version\\\"] >=\",\n \"= np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1,\",\n \"data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data =\",\n \"section listing spatial # transformations which have been eventually performed to create the\",\n \"processing. Compared to the # original file version \\\"1\\\", file versions 2 and\",\n \"data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # ---------------------------------------------------------------------\",\n \": 3D numpy.array Image data. \\\"\\\"\\\" header = dict() with open(filename, 'rb') as\",\n \"struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y axis data, =\",\n \"Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data\",\n \"iso-dimensions to which the data set will be internally \\\"expanded\\\" # for certain\",\n \"if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have\",\n \"binary data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"]\",\n \"header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"] f.write(struct.pack('<i', data))\",\n \"header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"]\",\n \"data)) # Expected binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data))\",\n \"(\\\"history record\\\"). The # post-header data can be probably ignored for custom routines,\",\n \"The axes terminology follows the internal BrainVoyager (BV) format. # The mapping to\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction vector Z\",\n \"= data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"]\",\n \"data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int\",\n \"data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"]\",\n \"headers. data : 3D numpy.array Image data. \\\"\\\"\\\" header = dict() with open(filename,\",\n \"The coordinate axes labels in these entries are not in # terms of\",\n \"# DICOM files. The coordinate axes labels in these entries are not in\",\n \"format. # The mapping to Talairach axes is as follows: # BV (X\",\n \"routines, but is # important in BrainVoyager QX for spatial transformation and #\",\n \"Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center X\",\n \"bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2))\",\n \"= header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values\",\n \"data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data\",\n \"struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1))\",\n \"= data # Field of view extent in column dir. [mm] data, =\",\n \"= header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h',\",\n \"transformation values as a list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): #\",\n \"but follow the DICOM # standard. Then follows eventually a section listing spatial\",\n \"header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float\",\n \"a value indicating the size of a cube with # iso-dimensions to which\",\n \"list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float\",\n \"binary data: unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size):\",\n \"(4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored as\",\n \": dictionary Header of VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center Y\",\n \"is # important in BrainVoyager QX for spatial transformation and # coregistration routines\",\n \"table is stored. The # \\\"type of transformation\\\" is a value determining how\",\n \"as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide\",\n \"integers). The VMR format contains a small header followed by the # actual\",\n \"past transformation, the # information specified in the following table is stored. The\",\n \"string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int (4\",\n \"np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B',\",\n \"int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data))\",\n \"data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"]\",\n \"Tal # Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for\",\n \"# Voxel resolution along Z axis # Expected binary data: char (1 byte)\",\n \"format contains a small header followed by the # actual data followed by\",\n \"f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected\",\n \"Z axis # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1))\",\n \"list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float\",\n \"data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"]\",\n \"= header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data =\",\n \"Returns ------- header : dictionary Pre-data and post-data headers. data : 3D numpy.array\",\n \"the assumed # left-right convention, the reference space (e.g. Talairach after # normalization)\",\n \"::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV\",\n \"header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide\",\n \"# DimY # DimX # # The axes terminology follows the internal BrainVoyager\",\n \"of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] =\",\n \"# Expected binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data\",\n \"back) [axis 2 after np.reshape] = Y in Tal space # BV (Y\",\n \"center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice\",\n \"f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center Y coordinate data, = struct.unpack('<f',\",\n \"vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column\",\n \"struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction vector Y component data,\",\n \"f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2,\",\n \"the original data set (\\\"history record\\\"). The # post-header data can be probably\",\n \"= Z in Tal space # BV (Z left -> right) [axis 0\",\n \"available) # and stores a series of spatial transformations, which might have been\",\n \"The information # in the post-data header contains position information (if available) #\",\n \"# 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data #\",\n \"component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction vector\",\n \"the data set will be internally \\\"expanded\\\" # for certain operations. The axes\",\n \"data: unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B',\",\n \"is \\\"4\\\", which is only slightly different from # version 3 (as indicated\",\n \"# Expected binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data\",\n \"data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data =\",\n \"# new in v4 # Expected binary data: float (4 bytes) data, =\",\n \"byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4 data,\",\n \"(as indicated below). Version 3 added offset values to # format 2 in\",\n \"# version 3 (as indicated below). Version 3 added offset values to #\",\n \"Y in Tal space # BV (Y top -> bottom) [axis 1 after\",\n \"header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"]\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float (4\",\n \"direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice\",\n \"the context of advanced segmentation processing. Compared to the # original file version\",\n \"bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view extent\",\n \"current VMR (e.g. ACPC transformation). Finally, additional # information further descries the data\",\n \"header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data))\",\n \"= Y in Tal space # BV (Y top -> bottom) [axis 1\",\n \"= data # First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"]\",\n \"data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i],\",\n \"column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data #\",\n \"entries are # identical to file version \\\"2\\\". # Expected binary data: short\",\n \"1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV\",\n \"struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view extent in column dir.\",\n \"as a series of bytes. See the V16 format # for a version\",\n \"binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1\",\n \"versions 2 and higher contain # additional header information after the actual data\",\n \"struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity data, = struct.unpack('<i',\",\n \"= data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data\",\n \"slightly different from # version 3 (as indicated below). Version 3 added offset\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows of slice\",\n \"data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"]\",\n \"[axis 0 after np.reshape] = X in Tal space # Expected binary data:\",\n \"range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) #\",\n \"float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data))\",\n \"(2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data\",\n \"= data # Field of view extent in row direction [mm] data, =\",\n \"f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B',\",\n \"identical to file version \\\"2\\\". # Expected binary data: short int (2 bytes)\",\n \"The # intensity values are stored as a series of bytes. See the\",\n \"Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of\",\n \"# NOTE(Developer Guide 2.6): For each past transformation, the # information specified in\",\n \"after np.reshape] = Y in Tal space # BV (Y top -> bottom)\",\n \"char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in\",\n \"center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice\",\n \"VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2\",\n \"matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"]\",\n \"direction vector Z component # Expected binary data: int (4 bytes) data, =\",\n \"transformation # \\\"5\\\": Un-Talairach transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] =\",\n \"original data set (\\\"history record\\\"). The # post-header data can be probably ignored\",\n \"followed by the # actual data followed by a second, more extensive, header.\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X axis data,\",\n \"= data # 16-bit data max intensity return header, data_img # ============================================================================= def\",\n \"Parameters ---------- filename : string Output filename. header : dictionary Header of VMR\",\n \"header[\\\"SliceNCenterY\\\"] = data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4))\",\n \"header[\\\"File version\\\"] >= 3: # Expected binary data: short int (2 bytes) data\",\n \"direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice\",\n \"specified in the following table is stored. The # \\\"type of transformation\\\" is\",\n \"range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img\",\n \"data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data =\",\n \"See the V16 format # for a version storing each intensity value with\",\n \"information specified in the following table is stored. The # \\\"type of transformation\\\"\",\n \"# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data sets,\",\n \"extensive, header. The current # version of VMR files is \\\"4\\\", which is\",\n \"# --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR\",\n \"byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- #\",\n \"= data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data\",\n \"data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR\",\n \"float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data))\",\n \"for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header #\",\n \"struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction vector Z component #\",\n \"data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- #\",\n \"component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction vector\",\n \"data # Field of view extent in row direction [mm] data, = struct.unpack('<f',\",\n \"# \\\"2\\\": Affine transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach transformation #\",\n \"binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values\",\n \"is stored. The # \\\"type of transformation\\\" is a value determining how many\",\n \"Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is\",\n \"NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented in 1\",\n \"data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data\",\n \"i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"],\",\n \"the original file headers, e.g. from # DICOM files. The coordinate axes labels\",\n \"for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data =\",\n \"struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction vector Y component data,\",\n \"is a value determining how many # subsequent values define the transformation: #\",\n \"16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit\",\n \"= data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data\",\n \"data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i',\",\n \"storing each intensity value with two bytes (short # integers). The VMR format\",\n \"file. Parameters ---------- filename : string Path to file. Returns ------- header :\",\n \"to write Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header\",\n \"normalization) and voxel resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6):\",\n \"\\\"expanded\\\" # for certain operations. The axes labels are in terms of #\",\n \"binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values\",\n \"header[\\\"ColDirZ\\\"] = data # Slice column direction vector Z component # Expected binary\",\n \"binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data,\",\n \"data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] =\",\n \"sets efficiently, e.g. in # the context of advanced segmentation processing. Compared to\",\n \"2 after np.reshape] = Y in Tal space # BV (Y top ->\",\n \"slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last\",\n \"f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center Z coordinate data, = struct.unpack('<f',\",\n \"\\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \\\"2\\\": Affine transformation\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values\",\n \"header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data))\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4\",\n \"(1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) #\",\n \"import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ----------\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view extent in row\",\n \"is # represented in 1 byte. The data is organized in three loops:\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y axis\",\n \"Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for i in\",\n \"header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data))\",\n \"data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal # Expected binary\",\n \"file version \\\"3\\\" with BrainVoyager QX 1.7. All other entries are # identical\",\n \"data sets with minimal header # checking if the extended information is not\",\n \"VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries\",\n \"Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data\",\n \"of rows of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data\",\n \"f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction vector Z component # Expected\",\n \"struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center X coordinate data, =\",\n \"data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data =\",\n \"VMR file. Parameters ---------- filename : string Path to file. Returns ------- header\",\n \"and contain offset values for # each dimension as well as a value\",\n \"view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data\",\n \"information (if available) # and stores a series of spatial transformations, which might\",\n \"Expected binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data =\",\n \"f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data)\",\n \"create the # current VMR (e.g. ACPC transformation). Finally, additional # information further\",\n \"struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data\",\n \"performed to create the # current VMR (e.g. ACPC transformation). Finally, additional #\",\n \"trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"]\",\n \"int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data, =\",\n \"data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, =\",\n \"data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int\",\n \"Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary\",\n \"header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data\",\n \"if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length\",\n \"data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] =\",\n \"in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"]\",\n \"-> right) [axis 0 after np.reshape] = X in Tal space # Expected\",\n \"Field of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"]\",\n \"not needed. The information # in the post-data header contains position information (if\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data\",\n \"center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice\",\n \"= data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR\",\n \"spatial # transformations which have been eventually performed to create the # current\",\n \"\\\"\\\"\\\" header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR\",\n \"# Slice column direction vector Z component # Expected binary data: int (4\",\n \"Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data\",\n \"# Store transformation values as a list trans_values = [] for j in\",\n \"determining how many # subsequent values define the transformation: # \\\"1\\\": Rigid body+scale\",\n \"# modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new\",\n \"header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float (4 bytes) data, = struct.unpack('<f',\",\n \"2, 1)) # BV to Tal # Expected binary data: unsigned char (1\",\n \"j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) #\",\n \"value determining how many # subsequent values define the transformation: # \\\"1\\\": Rigid\",\n \"header[\\\"ColDirX\\\"] = data # Slice column direction vector X component data, = struct.unpack('<f',\",\n \"data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data:\",\n \"data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1,\",\n \"= header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data =\",\n \"the extended information is not needed. The information # in the post-data header\",\n \"a value determining how many # subsequent values define the transformation: # \\\"1\\\":\",\n \"in v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))\",\n \"header = dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data\",\n \"followed by # scan position information from the original file headers, e.g. from\",\n \"# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"]\",\n \"probably ignored for custom routines, but is # important in BrainVoyager QX for\",\n \"Expected binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data =\",\n \"Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along\",\n \"values, 4x4 matrix) # \\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 -\",\n \"in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4\",\n \"[] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data\",\n \"series of bytes. See the V16 format # for a version storing each\",\n \"in # file version \\\"3\\\" with BrainVoyager QX 1.7. All other entries are\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide\",\n \"which might have been # performed to the original data set (\\\"history record\\\").\",\n \"set (\\\"history record\\\"). The # post-header data can be probably ignored for custom\",\n \"version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data))\",\n \"bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data\",\n \"open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- #\",\n \"component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction vector\",\n \"Tal space # BV (Y top -> bottom) [axis 1 after np.reshape] =\",\n \"f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction vector X component data, =\",\n \"data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"]\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of\",\n \"Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer\",\n \"# each dimension as well as a value indicating the size of a\",\n \"= struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4 data, = struct.unpack('<B',\",\n \"= struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int (4 bytes)\",\n \"= header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data =\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm] # Expected\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] =\",\n \"translation, 3 rotation, 3 scale) # \\\"2\\\": Affine transformation (16 values, 4x4 matrix)\",\n \"2.6): VMR files contain anatomical 3D data sets, # typically containing the whole\",\n \"a list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data:\",\n \"binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data:\",\n \"been added in # file version \\\"3\\\" with BrainVoyager QX 1.7. All other\",\n \"data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data\",\n \"[axis 2 after np.reshape] = Y in Tal space # BV (Y top\",\n \"3D numpy.array Image data. \\\"\\\"\\\" header = dict() with open(filename, 'rb') as f:\",\n \"0: # NOTE(Developer Guide 2.6): For each past transformation, the # information specified\",\n \"in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"]))\",\n \"byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"]\",\n \"Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary\",\n \"f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f',\",\n \"header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity data,\",\n \"transformation). Finally, additional # information further descries the data set, including the assumed\",\n \"data # 16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data\",\n \"BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img =\",\n \"def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename\",\n \"spatial transformation and # coregistration routines as well as for proper visualization. #\",\n \"ignored for custom routines, but is # important in BrainVoyager QX for spatial\",\n \"= data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2))\",\n \"other entries are # identical to file version \\\"2\\\". # Expected binary data:\",\n \"= struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data\",\n \"file. Parameters ---------- filename : string Output filename. header : dictionary Header of\",\n \"data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] =\",\n \"post-data headers. data : 3D numpy.array Image data. \\\"\\\"\\\" header = dict() with\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data\",\n \"header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"]\",\n \"slice image matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f',\",\n \"since file version \\\"3\\\" and contain offset values for # each dimension as\",\n \"Expected binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"]\",\n \"binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data #\",\n \"float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice\",\n \"float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution\",\n \"(1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) #\",\n \"\\\"type of transformation\\\" is a value determining how many # subsequent values define\",\n \"data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # ---------------------------------------------------------------------\",\n \"header[\\\"Slice1CenterY\\\"] = data # First slice center Y coordinate data, = struct.unpack('<f', f.read(4))\",\n \"# The axes terminology follows the internal BrainVoyager (BV) format. # The mapping\",\n \"# Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"]\",\n \"header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data))\",\n \"short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File version\\\"] = data data,\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"]\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4))\",\n \"in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field\",\n \"header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as a list trans_values = []\",\n \"header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"]\",\n \"and # coregistration routines as well as for proper visualization. # Expected binary\",\n \"offset values to # format 2 in order to represent large data sets\",\n \"well as for proper visualization. # Expected binary data: unsigned short int (2\",\n \"= header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data =\",\n \"np.reshape] = Y in Tal space # BV (Y top -> bottom) [axis\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity data, =\",\n \"# VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected\",\n \"internal BrainVoyager (BV) format. # The mapping to Talairach axes is as follows:\",\n \"for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"]\",\n \"binary data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]),\",\n \"the # original file version \\\"1\\\", file versions 2 and higher contain #\",\n \"struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view extent in row direction\",\n \"header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For each\",\n \"are # identical to file version \\\"2\\\". # Expected binary data: short int\",\n \"header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H',\",\n \"data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected\",\n \"# header\\\"). This allows to read VMR data sets with minimal header #\",\n \"data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to\",\n \"string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes)\",\n \"::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header #\",\n \"along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution\",\n \"VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f:\",\n \"extended information is not needed. The information # in the post-data header contains\",\n \"for spatial transformation and # coregistration routines as well as for proper visualization.\",\n \"i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # ---------------------------------------------------------------------\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data, =\",\n \"= data # Gap thickness [mm] # Expected binary data: int (4 bytes)\",\n \"string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes)\",\n \"data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"]\",\n \"indicated below). Version 3 added offset values to # format 2 in order\",\n \"16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img):\",\n \"data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] =\",\n \"transformations, which might have been # performed to the original data set (\\\"history\",\n \"vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity data, =\",\n \"each intensity value with two bytes (short # integers). The VMR format contains\",\n \"np.reshape] = Z in Tal space # BV (Z left -> right) [axis\",\n \"BV (Z left -> right) [axis 0 after np.reshape] = X in Tal\",\n \"internally \\\"expanded\\\" # for certain operations. The axes labels are in terms of\",\n \"data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int (4 bytes)\",\n \"= data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2))\",\n \"direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] = data # Slice\",\n \"= header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f',\",\n \"left-right convention, the reference space (e.g. Talairach after # normalization) and voxel resolution.\",\n \"extent in row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data #\",\n \"Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char\",\n \"context of advanced segmentation processing. Compared to the # original file version \\\"1\\\",\",\n \"contains a small header followed by the # actual data followed by a\",\n \"Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes)\",\n \"3 scale) # \\\"2\\\": Affine transformation (16 values, 4x4 matrix) # \\\"4\\\": Talairach\",\n \"header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img =\",\n \"define the transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3 scale)\",\n \"data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data:\",\n \"standard data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img,\",\n \"header\\\"). This allows to read VMR data sets with minimal header # checking\",\n \"extent in column dir. [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data #\",\n \"# Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected\",\n \"spatial transformations, which might have been # performed to the original data set\",\n \"header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4))\",\n \"trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char (1 byte) data, =\",\n \"data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"] f.write(struct.pack('<i', data)) return print(\\\"VMR\",\n \"of BrainVoyager's internal conventions but follow the DICOM # standard. Then follows eventually\",\n \"= header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f',\",\n \"following table is stored. The # \\\"type of transformation\\\" is a value determining\",\n \"data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data\",\n \"VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected binary\",\n \"higher contain # additional header information after the actual data (\\\"post-data # header\\\").\",\n \"vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column\",\n \"struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0,\",\n \"(Y top -> bottom) [axis 1 after np.reshape] = Z in Tal space\",\n \"from # version 3 (as indicated below). Version 3 added offset values to\",\n \"struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- #\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"]\",\n \"f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"]\",\n \"The VMR format contains a small header followed by the # actual data\",\n \"in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if\",\n \"# BV to Tal # Expected binary data: unsigned char (1 byte) data_img\",\n \"mapping to Talairach axes is as follows: # BV (X front -> back)\",\n \"struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity return header, data_img\",\n \"bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data:\",\n \"needed. The information # in the post-data header contains position information (if available)\",\n \"data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data =\",\n \"bottom) [axis 1 after np.reshape] = Z in Tal space # BV (Z\",\n \"return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager\",\n \"= X in Tal space # Expected binary data: unsigned char (1 byte)\",\n \"= header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f',\",\n \"data)) # Expected binary data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data))\",\n \"# Expected binary data: short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data))\",\n \"= header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data =\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data #\",\n \"are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): #\",\n \"2.6): Each data element (intensity value) is # represented in 1 byte. The\",\n \"# for certain operations. The axes labels are in terms of # BrainVoyager's\",\n \"struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation values as a list trans_values\",\n \"open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- #\",\n \"from the original file headers, e.g. from # DICOM files. The coordinate axes\",\n \"# Gap thickness [mm] # Expected binary data: int (4 bytes) data, =\",\n \"= header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): #\",\n \"bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"]\",\n \"data # Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"]\",\n \"# Expected binary data: unsigned short int (2 bytes) data = header[\\\"File version\\\"]\",\n \"Expected binary data: unsigned short int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H',\",\n \"Expected binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data =\",\n \"header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data))\",\n \"range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary\",\n \"Expected binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] =\",\n \"to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes # ---------------------------------------------------------------------\",\n \"NOTE(Developer Guide 2.6): For each past transformation, the # information specified in the\",\n \"header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"values to # format 2 in order to represent large data sets efficiently,\",\n \"data max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view extent in\",\n \"the following table is stored. The # \\\"type of transformation\\\" is a value\",\n \"by a second, more extensive, header. The current # version of VMR files\",\n \"data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data #\",\n \"struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction vector X component data,\",\n \"Brainvoyager VMR file. Parameters ---------- filename : string Path to file. Returns -------\",\n \"# \\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \\\"2\\\": Affine\",\n \"headers, e.g. from # DICOM files. The coordinate axes labels in these entries\",\n \"# \\\"5\\\": Un-Talairach transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] = []\",\n \"data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"]\",\n \"data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data\",\n \"Pre-data and post-data headers. data : 3D numpy.array Image data. \\\"\\\"\\\" header =\",\n \"information further descries the data set, including the assumed # left-right convention, the\",\n \"data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"]\",\n \"variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data: int (4\",\n \"value indicating the size of a cube with # iso-dimensions to which the\",\n \"data)) # Expected binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data))\",\n \"to Talairach axes is as follows: # BV (X front -> back) [axis\",\n \"j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f',\",\n \"# Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2))\",\n \"f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char (1 byte) data,\",\n \"additional header information after the actual data (\\\"post-data # header\\\"). This allows to\",\n \"header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data))\",\n \"file. Returns ------- header : dictionary Pre-data and post-data headers. data : 3D\",\n \"= struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img,\",\n \"Tal space # Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"]\",\n \"header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data))\",\n \"data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data\",\n \"header[\\\"LeftRightConvention\\\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] =\",\n \"= data # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))\",\n \"= data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"]\",\n \"file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f: #\",\n \">= 3: # Expected binary data: short int (2 bytes) data = header[\\\"OffsetX\\\"]\",\n \"bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data =\",\n \"string Path to file. Returns ------- header : dictionary Pre-data and post-data headers.\",\n \"data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data\",\n \"unsigned short int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data =\",\n \"# information specified in the following table is stored. The # \\\"type of\",\n \"5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) #\",\n \"read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to file.\",\n \"# DimZ # DimY # DimX # # The axes terminology follows the\",\n \"header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity return header, data_img # =============================================================================\",\n \"bytes (short # integers). The VMR format contains a small header followed by\",\n \"f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"] f.write(struct.pack('<i', data)) return\",\n \"data # Gap thickness [mm] # Expected binary data: int (4 bytes) data,\",\n \"data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"]\",\n \"as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary\",\n \"data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1))\",\n \"# Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data\",\n \"bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"]\",\n \"position information (if available) # and stores a series of spatial transformations, which\",\n \"data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"]\",\n \"Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] # Flip\",\n \"record\\\"). The # post-header data can be probably ignored for custom routines, but\",\n \"in Tal space # Expected binary data: unsigned char (1 byte) data_img =\",\n \"file version \\\"3\\\" and contain offset values for # each dimension as well\",\n \"int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data))\",\n \"header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data: int\",\n \"header[\\\"NCols\\\"] = data # Nr of columns of slice image matrix # Expected\",\n \"VMR file. Parameters ---------- filename : string Output filename. header : dictionary Header\",\n \"= header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f',\",\n \"axis # Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"]\",\n \"information is not needed. The information # in the post-data header contains position\",\n \"= header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data:\",\n \"data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data =\",\n \"f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data:\",\n \"(4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) #\",\n \"\\\"3\\\" and contain offset values for # each dimension as well as a\",\n \"data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data))\",\n \"is organized in three loops: # DimZ # DimY # DimX # #\",\n \"intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] =\",\n \"f.read(4)) header[\\\"RowDirY\\\"] = data # Slice row direction vector Y component data, =\",\n \"a cube with # iso-dimensions to which the data set will be internally\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1\",\n \"data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data =\",\n \"version 3 (as indicated below). Version 3 added offset values to # format\",\n \"header[\\\"RowDirZ\\\"] = data # Slice row direction vector Z component data, = struct.unpack('<f',\",\n \"row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data #\",\n \"data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation,\",\n \"labels are in terms of # BrainVoyager's internal format. These four entries are\",\n \"the data set, including the assumed # left-right convention, the reference space (e.g.\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data\",\n \"how many # subsequent values define the transformation: # \\\"1\\\": Rigid body+scale (3\",\n \"2.6): These four entries have been added in # file version \\\"3\\\" with\",\n \"# --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the post-data\",\n \"with minimal header # checking if the extended information is not needed. The\",\n \"BV axes) header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary\",\n \"= header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary data:\",\n \"int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h',\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data\",\n \"struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 # Expected binary data:\",\n \"struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit data mean intensity data, = struct.unpack('<i',\",\n \"= header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f',\",\n \"f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For\",\n \"data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header\",\n \"= data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data:\",\n \"write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename :\",\n \": dictionary Pre-data and post-data headers. data : 3D numpy.array Image data. \\\"\\\"\\\"\",\n \"# NOTE(Developer Guide 2.6): These four entries have been added in # file\",\n \"# subsequent values define the transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3\",\n \"data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified\",\n \"struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X axis data, =\",\n \"be internally \\\"expanded\\\" # for certain operations. The axes labels are in terms\",\n \"f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i',\",\n \"range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data)\",\n \"= data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2))\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center Y coordinate data,\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4\",\n \"first four entries of the post-data # header are new since file version\",\n \"# BrainVoyager's internal format. These four entries are followed by # scan position\",\n \"and voxel resolution. if header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6): These\",\n \"a small header followed by the # actual data followed by a second,\",\n \"data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\")\",\n \"header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"]\",\n \"For each past transformation, the # information specified in the following table is\",\n \"--------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first\",\n \"data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B',\",\n \"Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness\",\n \"data sets, # typically containing the whole brain (head) of subjects. The #\",\n \"Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected binary data:\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows of slice image\",\n \"struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns of slice image matrix\",\n \"with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header # ---------------------------------------------------------------------\",\n \"write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename :\",\n \"data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 # Expected\",\n \"(short # integers). The VMR format contains a small header followed by the\",\n \"3D data sets, # typically containing the whole brain (head) of subjects. The\",\n \"sets with minimal header # checking if the extended information is not needed.\",\n \"ACPC transformation). Finally, additional # information further descries the data set, including the\",\n \"header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data\",\n \"post-data # header are new since file version \\\"3\\\" and contain offset values\",\n \"subsequent values define the transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3 rotation,\",\n \"resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel\",\n \"# BV (Y top -> bottom) [axis 1 after np.reshape] = Z in\",\n \"Guide 2.6): Each data element (intensity value) is # represented in 1 byte.\",\n \"of spatial transformations, which might have been # performed to the original data\",\n \"= header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f',\",\n \"Expected binary data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data =\",\n \"front -> back) [axis 2 after np.reshape] = Y in Tal space #\",\n \"= data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data:\",\n \"f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center X coordinate data, = struct.unpack('<f',\",\n \"Each data element (intensity value) is # represented in 1 byte. The data\",\n \"are followed by # scan position information from the original file headers, e.g.\",\n \"--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value) is # represented\",\n \"f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) #\",\n \"\\\"\\\"\\\" with open(filename, 'wb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header #\",\n \"header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\\\"NRows\\\"]\",\n \"Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H', f.read(2)) header[\\\"File\",\n \"in 1 byte. The data is organized in three loops: # DimZ #\",\n \"# for a version storing each intensity value with two bytes (short #\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if\",\n \"char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data))\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data\",\n \"Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data\",\n \"f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer\",\n \"# original file version \\\"1\\\", file versions 2 and higher contain # additional\",\n \"Image data. \\\"\\\"\\\" header = dict() with open(filename, 'rb') as f: # ---------------------------------------------------------------------\",\n \"# --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard\",\n \"Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected\",\n \"of the post-data # header are new since file version \\\"3\\\" and contain\",\n \"data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] =\",\n \"= struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data\",\n \"= header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data)) # Expected binary data:\",\n \"files. The coordinate axes labels in these entries are not in # terms\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data\",\n \"rotation, 3 scale) # \\\"2\\\": Affine transformation (16 values, 4x4 matrix) # \\\"4\\\":\",\n \"struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int (4 bytes) data,\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction vector Z\",\n \"header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"]\",\n \"2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip\",\n \"short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h',\",\n \"but is # important in BrainVoyager QX for spatial transformation and # coregistration\",\n \"header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary\",\n \"string Output filename. header : dictionary Header of VMR file. data_img : numpy.array,\",\n \"more extensive, header. The current # version of VMR files is \\\"4\\\", which\",\n \"data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR\",\n \"BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide\",\n \"--------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back\",\n \"bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data =\",\n \"byte. The data is organized in three loops: # DimZ # DimY #\",\n \"# represented in 1 byte. The data is organized in three loops: #\",\n \"data)) # Expected binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data))\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min intensity\",\n \"been # performed to the original data set (\\\"history record\\\"). The # post-header\",\n \"(4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i\",\n \"row direction [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of\",\n \"as a value indicating the size of a cube with # iso-dimensions to\",\n \"contain offset values for # each dimension as well as a value indicating\",\n \"# information further descries the data set, including the assumed # left-right convention,\",\n \"header[\\\"FoVRows\\\"] = data # Field of view extent in row direction [mm] data,\",\n \"data # First slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] =\",\n \"for a version storing each intensity value with two bytes (short # integers).\",\n \"a series of spatial transformations, which might have been # performed to the\",\n \"# Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] =\",\n \"as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager\",\n \"data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B',\",\n \"Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data #\",\n \"data)) # Expected binary data: char (1 byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data))\",\n \"# Field of view extent in column dir. [mm] data, = struct.unpack('<f', f.read(4))\",\n \"data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int (4 bytes)\",\n \"# Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data\",\n \"struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float (4 bytes) data,\",\n \"(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center\",\n \"f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y axis data, = struct.unpack('<f',\",\n \"data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected\",\n \"data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti\",\n \"f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, =\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data\",\n \"data # Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"]\",\n \"BV to Tal # Expected binary data: unsigned char (1 byte) data_img =\",\n \"(header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal\",\n \"(3 translation, 3 rotation, 3 scale) # \\\"2\\\": Affine transformation (16 values, 4x4\",\n \"element (intensity value) is # represented in 1 byte. The data is organized\",\n \"Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction\",\n \"BrainVoyager's internal format. These four entries are followed by # scan position information\",\n \"dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img,\",\n \"np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR\",\n \"# --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard data_img\",\n \"Output filename. header : dictionary Header of VMR file. data_img : numpy.array, 3D\",\n \"header. The current # version of VMR files is \\\"4\\\", which is only\",\n \"data)) # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) #\",\n \"# Last slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data\",\n \"= header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimZ\\\"] f.write(struct.pack('<H',\",\n \"slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of\",\n \"a version storing each intensity value with two bytes (short # integers). The\",\n \"post-data header contains position information (if available) # and stores a series of\",\n \"np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) # BV\",\n \"f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int (4 bytes) data, =\",\n \"header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int\",\n \"data)) # Expected binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data))\",\n \"# --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # Expected binary data: unsigned\",\n \"variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int\",\n \"2 in order to represent large data sets efficiently, e.g. in # the\",\n \"advanced segmentation processing. Compared to the # original file version \\\"1\\\", file versions\",\n \"data element (intensity value) is # represented in 1 byte. The data is\",\n \"of subjects. The # intensity values are stored as a series of bytes.\",\n \"data # 16-bit data max intensity return header, data_img # ============================================================================= def write_vmr(filename,\",\n \"2.6): For each past transformation, the # information specified in the following table\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data\",\n \"= data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2,\",\n \"Brainvoyager VMR file. Parameters ---------- filename : string Output filename. header : dictionary\",\n \"f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary\",\n \"and higher contain # additional header information after the actual data (\\\"post-data #\",\n \"space # BV (Y top -> bottom) [axis 1 after np.reshape] = Z\",\n \"labels in these entries are not in # terms of BrainVoyager's internal conventions\",\n \"data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) # Expected binary\",\n \"data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data =\",\n \"# Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to\",\n \"VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical\",\n \"!= 0: # NOTE(Developer Guide 2.6): For each past transformation, the # information\",\n \"unsigned char (1 byte) data_img = data_img.flatten() for i in range(data_img.size): f.write(struct.pack('<B', data_img[i]))\",\n \"coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center Z\",\n \"thickness [mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))\",\n \"if header[\\\"File version\\\"] >= 3: # Expected binary data: short int (2 bytes)\",\n \"binary data: float (4 bytes) data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"]\",\n \"data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary data: char (1 byte) data\",\n \"which the data set will be internally \\\"expanded\\\" # for certain operations. The\",\n \"convention, the reference space (e.g. Talairach after # normalization) and voxel resolution. if\",\n \"i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f,\",\n \"header[\\\"PastTransformation\\\"] = [] for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length\",\n \"data # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each\",\n \"byte) data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected\",\n \"header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list trans_values =\",\n \"follows the internal BrainVoyager (BV) format. # The mapping to Talairach axes is\",\n \"as a list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] = data # Slice column direction vector X\",\n \"f.write(struct.pack('<B', data)) # Expected binary data: int (4 bytes) data = header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i',\",\n \"assumed # left-right convention, the reference space (e.g. Talairach after # normalization) and\",\n \"to read VMR data sets with minimal header # checking if the extended\",\n \"(head) of subjects. The # intensity values are stored as a series of\",\n \"header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"]\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm] # Expected binary\",\n \"First slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data #\",\n \"Store transformation values as a list trans_values = [] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]):\",\n \"Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal\",\n \"header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data))\",\n \"# Slice column direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] =\",\n \"(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of view\",\n \"short int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"]\",\n \"data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"]\",\n \"# BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes\",\n \"data followed by a second, more extensive, header. The current # version of\",\n \"f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float (4\",\n \"VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity value)\",\n \"e.g. in # the context of advanced segmentation processing. Compared to the #\",\n \"This allows to read VMR data sets with minimal header # checking if\",\n \"version \\\"3\\\" and contain offset values for # each dimension as well as\",\n \"data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data:\",\n \"# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] =\",\n \"standard. Then follows eventually a section listing spatial # transformations which have been\",\n \"data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) # Expected binary\",\n \"data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >=\",\n \"= struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- # VMR Data # ---------------------------------------------------------------------\",\n \"struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center Y coordinate data, =\",\n \"\\\"5\\\": Un-Talairach transformation (1 - 5 -> BV axes) header[\\\"PastTransformation\\\"] = [] for\",\n \"= struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 # Expected binary\",\n \"# version of VMR files is \\\"4\\\", which is only slightly different from\",\n \"= data # Nr of rows of slice image matrix data, = struct.unpack('<i',\",\n \"stored. The # \\\"type of transformation\\\" is a value determining how many #\",\n \"data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] =\",\n \"bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in\",\n \"# ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename : string\",\n \"[mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm] #\",\n \"DimZ # DimY # DimX # # The axes terminology follows the internal\",\n \"3 added offset values to # format 2 in order to represent large\",\n \"data set, including the assumed # left-right convention, the reference space (e.g. Talairach\",\n \"= data # Last slice center Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"]\",\n \"= data # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] =\",\n \"# and stores a series of spatial transformations, which might have been #\",\n \"f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File version\\\"]\",\n \"# Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"] =\",\n \"stored as a series of bytes. See the V16 format # for a\",\n \"by the # actual data followed by a second, more extensive, header. The\",\n \"information # in the post-data header contains position information (if available) # and\",\n \"by # scan position information from the original file headers, e.g. from #\",\n \"[mm] # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"]\",\n \"data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char\",\n \"data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] =\",\n \"binary data: unsigned short int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data))\",\n \"f: # --------------------------------------------------------------------- # VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):\",\n \"int (2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H',\",\n \"range(data_img.size): f.write(struct.pack('<B', data_img[i])) # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- if header[\\\"File\",\n \"slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values # Expected binary data: char (1 byte) data, = struct.unpack('<B',\",\n \"v4 # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"]\",\n \"header[\\\"Slice1CenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data))\",\n \"space # Expected binary data: unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] *\",\n \"X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center\",\n \"version\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H',\",\n \"in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))\",\n \"f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"]\",\n \"import struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # =============================================================================\",\n \"--------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the post-data #\",\n \"binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data #\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data, = struct.unpack('<f',\",\n \"header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data))\",\n \"# checking if the extended information is not needed. The information # in\",\n \"int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for\",\n \"in Tal space # BV (Y top -> bottom) [axis 1 after np.reshape]\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"FoVCols\\\"] = data # Field of view extent in\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] = data # Store transformation\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns of slice\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data\",\n \"for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1)) data_img = np.reshape( data_img, (header[\\\"DimZ\\\"],\",\n \"data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"]\",\n \"data # Slice row direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"]\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center X coordinate data,\",\n \"BrainVoyager's internal conventions but follow the DICOM # standard. Then follows eventually a\",\n \"= data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"]\",\n \"Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data\",\n \"Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain anatomical 3D data\",\n \"Finally, additional # information further descries the data set, including the assumed #\",\n \"Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data\",\n \"= header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"]\",\n \"can be probably ignored for custom routines, but is # important in BrainVoyager\",\n \"of transformation\\\" is a value determining how many # subsequent values define the\",\n \"binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary\",\n \"data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: for i in range(header[\\\"NrOfPastSpatialTransformations\\\"]):\",\n \"slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last\",\n \"Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV standard\",\n \"np.transpose(data_img, (0, 2, 1)) # BV to Tal data_img = data_img[::-1, ::-1, ::-1]\",\n \": string Path to file. Returns ------- header : dictionary Pre-data and post-data\",\n \"= data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))\",\n \"struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm] # Expected binary data:\",\n \"numpy.array Image data. \\\"\\\"\\\" header = dict() with open(filename, 'rb') as f: #\",\n \"\\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ---------- filename : string Output filename.\",\n \"# VMR Data # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): Each data element (intensity\",\n \"entries are not in # terms of BrainVoyager's internal conventions but follow the\",\n \"# important in BrainVoyager QX for spatial transformation and # coregistration routines as\",\n \"eventually a section listing spatial # transformations which have been eventually performed to\",\n \"header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected binary data: int\",\n \"data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary\",\n \"header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H',\",\n \"in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected\",\n \"(1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1))\",\n \"binary data: short int (2 bytes) data = header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data =\",\n \"# Slice row direction vector X component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirY\\\"] =\",\n \"f.read(2)) header[\\\"OffsetY\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, =\",\n \"int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data))\",\n \"data = header[\\\"VoxelResolutionVerified\\\"] f.write(struct.pack('<B', data)) data = header[\\\"VoxelResolutionInTALmm\\\"] f.write(struct.pack('<B', data)) # Expected binary\",\n \"of advanced segmentation processing. Compared to the # original file version \\\"1\\\", file\",\n \"= np.reshape( data_img, (header[\\\"DimZ\\\"], header[\\\"DimY\\\"], header[\\\"DimX\\\"])) data_img = np.transpose(data_img, (0, 2, 1)) #\",\n \"data can be probably ignored for custom routines, but is # important in\",\n \"X in Tal space # Expected binary data: unsigned char (1 byte) data_img\",\n \"Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"] = data # Slice column direction\",\n \"coordinate axes labels in these entries are not in # terms of BrainVoyager's\",\n \"data # Slice row direction vector Z component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirX\\\"]\",\n \"axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z\",\n \"data # Slice column direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"ColDirZ\\\"]\",\n \"of columns of slice image matrix # Expected binary data: float (4 bytes)\",\n \"Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four entries of the\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows of\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"] f.write(struct.pack('<f', data)) #\",\n \"with # iso-dimensions to which the data set will be internally \\\"expanded\\\" #\",\n \"# typically containing the whole brain (head) of subjects. The # intensity values\",\n \"second, more extensive, header. The current # version of VMR files is \\\"4\\\",\",\n \"data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First\",\n \"represented in 1 byte. The data is organized in three loops: # DimZ\",\n \"# Expected binary data: int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data\",\n \"# standard. Then follows eventually a section listing spatial # transformations which have\",\n \"header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data))\",\n \"three loops: # DimZ # DimY # DimX # # The axes terminology\",\n \"(4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) #\",\n \"from Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1] #\",\n \"data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) # Expected\",\n \"data: float (4 bytes) f.write(struct.pack('<f', trans_values[j])) # Expected binary data: char (1 byte)\",\n \"# Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] =\",\n \"data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeZ\\\"]\",\n \"header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4))\",\n \"(2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, = struct.unpack('<h', f.read(2))\",\n \": string Output filename. header : dictionary Header of VMR file. data_img :\",\n \"v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"] = data # new in v4 #\",\n \"data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as f: # ---------------------------------------------------------------------\",\n \"in the following table is stored. The # \\\"type of transformation\\\" is a\",\n \"data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data # Expected binary data: int (4\",\n \"after np.reshape] = Z in Tal space # BV (Z left -> right)\",\n \"= header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f',\",\n \"direction vector Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice\",\n \"Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center\",\n \"= data # Voxel resolution along X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"]\",\n \"routines as well as for proper visualization. # Expected binary data: unsigned short\",\n \"file version \\\"1\\\", file versions 2 and higher contain # additional header information\",\n \"a second, more extensive, header. The current # version of VMR files is\",\n \"f.read(1)) header[\\\"VoxelResolutionVerified\\\"] = data data, = struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected\",\n \"with two bytes (short # integers). The VMR format contains a small header\",\n \"data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data #\",\n \"data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field\",\n \"= header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirZ\\\"] f.write(struct.pack('<f',\",\n \"= data # Store transformation values as a list trans_values = [] for\",\n \"= header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert\",\n \"header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int (4 bytes) data, = struct.unpack('<i',\",\n \"data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4 bytes)\",\n \"header[\\\"NRows\\\"] = data # Nr of rows of slice image matrix data, =\",\n \"X axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along\",\n \"header[\\\"SliceThickness\\\"] = data # Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] =\",\n \"file versions 2 and higher contain # additional header information after the actual\",\n \"of slice image matrix data, = struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr\",\n \"data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"]\",\n \"cube with # iso-dimensions to which the data set will be internally \\\"expanded\\\"\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity return header,\",\n \"# header are new since file version \\\"3\\\" and contain offset values for\",\n \"conventions but follow the DICOM # standard. Then follows eventually a section listing\",\n \"data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0,\",\n \"============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file. Parameters ----------\",\n \"data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"] = data # Expected binary data: float\",\n \"data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel\",\n \"f.write(struct.pack('<h', data)) # Expected binary data: int (4 bytes) data = header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i',\",\n \"binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"]\",\n \"Z component # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4))\",\n \"= data # Slice column direction vector X component data, = struct.unpack('<f', f.read(4))\",\n \"char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i\",\n \"Voxel resolution along Y axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeZ\\\"] = data #\",\n \"have been eventually performed to create the # current VMR (e.g. ACPC transformation).\",\n \"performed to the original data set (\\\"history record\\\"). The # post-header data can\",\n \"(BV) format. # The mapping to Talairach axes is as follows: # BV\",\n \"original file headers, e.g. from # DICOM files. The coordinate axes labels in\",\n \"column direction vector Z component # Expected binary data: int (4 bytes) data,\",\n \"binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] !=\",\n \"binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary\",\n \"to the original data set (\\\"history record\\\"). The # post-header data can be\",\n \"Header # --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected binary data: short\",\n \"header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation, the #\",\n \"int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data\",\n \"f.read(2)) header[\\\"DimX\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimY\\\"] = data data, =\",\n \"f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X axis data, = struct.unpack('<f',\",\n \"data)) data = header[\\\"SliceThickness\\\"] f.write(struct.pack('<f', data)) data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected\",\n \"Talairach axes is as follows: # BV (X front -> back) [axis 2\",\n \"# in the post-data header contains position information (if available) # and stores\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row direction vector X\",\n \"efficiently, e.g. in # the context of advanced segmentation processing. Compared to the\",\n \"stores a series of spatial transformations, which might have been # performed to\",\n \"\\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename : string Path to file. Returns\",\n \"bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterX\\\"] = data # First slice center X\",\n \"BV to Tal data_img = data_img[::-1, ::-1, ::-1] # Flip BV axes #\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if header[\\\"NrOfPastSpatialTransformations\\\"] != 0:\",\n \"(2 bytes) data = header[\\\"File version\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data))\",\n \"# VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): The first four\",\n \"Convert axes from Nifti standard back to BV standard data_img = data_img[::-1, ::-1,\",\n \"the reference space (e.g. Talairach after # normalization) and voxel resolution. if header[\\\"File\",\n \"binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data) # Expected binary data:\",\n \"header[\\\"RowDirY\\\"] = data # Slice row direction vector Y component data, = struct.unpack('<f',\",\n \"# Expected binary data: unsigned char (1 byte) data_img = data_img.flatten() for i\",\n \"header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]\",\n \"# the context of advanced segmentation processing. Compared to the # original file\",\n \"are not in # terms of BrainVoyager's internal conventions but follow the DICOM\",\n \"Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data # Last slice center\",\n \">= 3: # NOTE(Developer Guide 2.6): These four entries have been added in\",\n \"dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header #\",\n \"byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected\",\n \"data: float (4 bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f',\",\n \"string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] = data # Expected binary data: int (4\",\n \"# Nr of columns of slice image matrix # Expected binary data: float\",\n \"VMR Data # --------------------------------------------------------------------- # Convert axes from Nifti standard back to BV\",\n \"range(header[\\\"NrOfPastSpatialTransformations\\\"]): header[\\\"PastTransformation\\\"].append(dict()) # Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] =\",\n \"(4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along\",\n \"struct import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def\",\n \"# current VMR (e.g. ACPC transformation). Finally, additional # information further descries the\",\n \"---------- filename : string Path to file. Returns ------- header : dictionary Pre-data\",\n \"# Convert axes from Nifti standard back to BV standard data_img = data_img[::-1,\",\n \"float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] = data # Field of\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterZ\\\"] = data # First slice center Z coordinate data,\",\n \"reference space (e.g. Talairach after # normalization) and voxel resolution. if header[\\\"File version\\\"]\",\n \"data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data =\",\n \"well as a value indicating the size of a cube with # iso-dimensions\",\n \"Guide 2.6): VMR files contain anatomical 3D data sets, # typically containing the\",\n \"Path to file. Returns ------- header : dictionary Pre-data and post-data headers. data\",\n \"The axes labels are in terms of # BrainVoyager's internal format. These four\",\n \"to file version \\\"2\\\". # Expected binary data: short int (2 bytes) data,\",\n \"header information after the actual data (\\\"post-data # header\\\"). This allows to read\",\n \"The mapping to Talairach axes is as follows: # BV (X front ->\",\n \"# NOTE(Developer Guide 2.6): The first four entries of the post-data # header\",\n \"a series of bytes. See the V16 format # for a version storing\",\n \"# identical to file version \\\"2\\\". # Expected binary data: short int (2\",\n \"version \\\"3\\\" with BrainVoyager QX 1.7. All other entries are # identical to\",\n \"# Expected binary data: variable-length string data = read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data #\",\n \"additional # information further descries the data set, including the assumed # left-right\",\n \"f.read(2)) header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # ---------------------------------------------------------------------\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data # 16-bit data max intensity return\",\n \"current # version of VMR files is \\\"4\\\", which is only slightly different\",\n \"# \\\"type of transformation\\\" is a value determining how many # subsequent values\",\n \"np.reshape] = X in Tal space # Expected binary data: unsigned char (1\",\n \"= data # Slice column direction vector Z component # Expected binary data:\",\n \"byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size):\",\n \"BV axes data_img = np.transpose(data_img, (0, 2, 1)) # BV to Tal #\",\n \"numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read\",\n \"16-bit data min intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MeanValue\\\"] = data # 16-bit\",\n \"Expected binary data: char (1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data\",\n \"= dict() with open(filename, 'rb') as f: # --------------------------------------------------------------------- # VMR Pre-Data Header\",\n \"information after the actual data (\\\"post-data # header\\\"). This allows to read VMR\",\n \"header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z coordinate data, = struct.unpack('<f', f.read(4))\",\n \"in range(header[\\\"NrOfPastSpatialTransformations\\\"]): # Expected binary data: variable-length string data = header[\\\"PastTransformation\\\"][i][\\\"Name\\\"] write_variable_length_string(f, data)\",\n \"subjects. The # intensity values are stored as a series of bytes. See\",\n \"= header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data =\",\n \"f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4 data, = struct.unpack('<B', f.read(1)) header[\\\"ReferenceSpaceVMR\\\"]\",\n \"bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a\",\n \"axes terminology follows the internal BrainVoyager (BV) format. # The mapping to Talairach\",\n \"# --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data =\",\n \"from # DICOM files. The coordinate axes labels in these entries are not\",\n \"data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data)) data =\",\n \"First slice center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterX\\\"] = data #\",\n \"# Slice thickness [mm] data, = struct.unpack('<f', f.read(4)) header[\\\"GapThickness\\\"] = data # Gap\",\n \"for custom routines, but is # important in BrainVoyager QX for spatial transformation\",\n \"* header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in range(data_img.size): data_img[i], = struct.unpack('<B', f.read(1))\",\n \"(1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for i in\",\n \"as well as a value indicating the size of a cube with #\",\n \"transformation, the # information specified in the following table is stored. The #\",\n \"certain operations. The axes labels are in terms of # BrainVoyager's internal format.\",\n \"(read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters ---------- filename\",\n \"= struct.unpack('<f', f.read(4)) header[\\\"ColDirY\\\"] = data # Slice column direction vector Y component\",\n \"= struct.unpack('<i', f.read(4)) header[\\\"NCols\\\"] = data # Nr of columns of slice image\",\n \"the size of a cube with # iso-dimensions to which the data set\",\n \"f.read(4)) header[\\\"VoxelSizeZ\\\"] = data # Voxel resolution along Z axis # Expected binary\",\n \"struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z coordinate data, =\",\n \"data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data)) if header[\\\"NrOfPastSpatialTransformations\\\"] != 0:\",\n \"int (4 bytes) data = header[\\\"NRows\\\"] f.write(struct.pack('<i', data)) data = header[\\\"NCols\\\"] f.write(struct.pack('<i', data))\",\n \"data set will be internally \\\"expanded\\\" # for certain operations. The axes labels\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"NrOfPastSpatialTransformations\\\"] = data if\",\n \"header[\\\"Slice1CenterZ\\\"] = data # First slice center Z coordinate data, = struct.unpack('<f', f.read(4))\",\n \"data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] = trans_values #\",\n \"center Z coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirX\\\"] = data # Slice row\",\n \"data = header[\\\"FoVRows\\\"] f.write(struct.pack('<f', data)) data = header[\\\"FoVCols\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceThickness\\\"]\",\n \"data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"]\",\n \"version\\\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have been added\",\n \"a section listing spatial # transformations which have been eventually performed to create\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"Slice1CenterY\\\"] = data # First slice center Y coordinate\",\n \"f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h', data)) data = header[\\\"FramingCubeDim\\\"] f.write(struct.pack('<h', data)) #\",\n \"trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4\",\n \"header[\\\"File version\\\"] >= 3: # NOTE(Developer Guide 2.6): These four entries have been\",\n \"X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] = data # Last slice center\",\n \"data # new in v4 # Expected binary data: float (4 bytes) data,\",\n \"binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data,\",\n \"data # Last slice center X coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterY\\\"] =\",\n \"transformation: # \\\"1\\\": Rigid body+scale (3 translation, 3 rotation, 3 scale) # \\\"2\\\":\",\n \"# VMR Pre-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6): VMR files contain\",\n \"containing the whole brain (head) of subjects. The # intensity values are stored\",\n \"(e.g. ACPC transformation). Finally, additional # information further descries the data set, including\",\n \"BrainVoyager (BV) format. # The mapping to Talairach axes is as follows: #\",\n \"\\\"4\\\": Talairach transformation # \\\"5\\\": Un-Talairach transformation (1 - 5 -> BV axes)\",\n \"if header[\\\"NrOfPastSpatialTransformations\\\"] != 0: # NOTE(Developer Guide 2.6): For each past transformation, the\",\n \"f.write(struct.pack('<H', data)) data = header[\\\"DimX\\\"] f.write(struct.pack('<H', data)) data = header[\\\"DimY\\\"] f.write(struct.pack('<H', data)) data\",\n \"bytes) data = header[\\\"VoxelSizeX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"VoxelSizeY\\\"] f.write(struct.pack('<f', data)) data =\",\n \"header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"RowDirY\\\"] f.write(struct.pack('<f', data))\",\n \"data = header[\\\"GapThickness\\\"] f.write(struct.pack('<f', data)) # Expected binary data: int (4 bytes) data\",\n \"sets, # typically containing the whole brain (head) of subjects. The # intensity\",\n \"visualization. # Expected binary data: unsigned short int (2 bytes) data, = struct.unpack('<H',\",\n \"= header[\\\"OffsetX\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetY\\\"] f.write(struct.pack('<h', data)) data = header[\\\"OffsetZ\\\"] f.write(struct.pack('<h',\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirZ\\\"] f.write(struct.pack('<f', data)) #\",\n \"data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i', data)) # Transformation values are stored as a list\",\n \"indicating the size of a cube with # iso-dimensions to which the data\",\n \"format. These four entries are followed by # scan position information from the\",\n \"data)) # Expected binary data: int (4 bytes) data = header[\\\"NrOfPastSpatialTransformations\\\"] f.write(struct.pack('<i', data))\",\n \"= header[\\\"PosInfosVerified\\\"] f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data:\",\n \"data_img[::-1, ::-1, ::-1] # Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header\",\n \"f.read(4)) header[\\\"GapThickness\\\"] = data # Gap thickness [mm] # Expected binary data: int\",\n \"and post-data headers. data : 3D numpy.array Image data. \\\"\\\"\\\" header = dict()\",\n \"BrainVoyager QX for spatial transformation and # coregistration routines as well as for\",\n \"data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR file.\",\n \"Header of VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb')\",\n \"unsigned char (1 byte) data_img = np.zeros((header[\\\"DimZ\\\"] * header[\\\"DimY\\\"] * header[\\\"DimX\\\"]), dtype=\\\"<B\\\") for\",\n \"internal conventions but follow the DICOM # standard. Then follows eventually a section\",\n \"data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"] f.write(struct.pack('<i', data)) return print(\\\"VMR saved.\\\")\",\n \"terms of # BrainVoyager's internal format. These four entries are followed by #\",\n \"follow the DICOM # standard. Then follows eventually a section listing spatial #\",\n \"= struct.unpack('<h', f.read(2)) header[\\\"OffsetZ\\\"] = data data, = struct.unpack('<h', f.read(2)) header[\\\"FramingCubeDim\\\"] = data\",\n \"data)) data = header[\\\"Slice1CenterZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterX\\\"] f.write(struct.pack('<f', data)) data =\",\n \"the actual data (\\\"post-data # header\\\"). This allows to read VMR data sets\",\n \"header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data = header[\\\"ReferenceSpaceVMR\\\"] f.write(struct.pack('<B', data)) # Expected binary data: float\",\n \"Talairach after # normalization) and voxel resolution. if header[\\\"File version\\\"] >= 3: #\",\n \"struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction vector Z component data,\",\n \"data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeX\\\"] = data # Voxel resolution along X axis\",\n \"Header # --------------------------------------------------------------------- # Expected binary data: unsigned short int (2 bytes) data\",\n \"descries the data set, including the assumed # left-right convention, the reference space\",\n \"# file version \\\"3\\\" with BrainVoyager QX 1.7. All other entries are #\",\n \"Z in Tal space # BV (Z left -> right) [axis 0 after\",\n \"# --------------------------------------------------------------------- if header[\\\"File version\\\"] >= 3: # Expected binary data: short int\",\n \"Then follows eventually a section listing spatial # transformations which have been eventually\",\n \"of VMR file. data_img : numpy.array, 3D Image. \\\"\\\"\\\" with open(filename, 'wb') as\",\n \"two bytes (short # integers). The VMR format contains a small header followed\",\n \"to the # original file version \\\"1\\\", file versions 2 and higher contain\",\n \"f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center Z coordinate data, = struct.unpack('<f',\",\n \"small header followed by the # actual data followed by a second, more\",\n \"operations. The axes labels are in terms of # BrainVoyager's internal format. These\",\n \"import numpy as np from bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename):\",\n \"listing spatial # transformations which have been eventually performed to create the #\",\n \"follows: # BV (X front -> back) [axis 2 after np.reshape] = Y\",\n \"terminology follows the internal BrainVoyager (BV) format. # The mapping to Talairach axes\",\n \"# Flip BV axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- #\",\n \"header[\\\"ColDirY\\\"] = data # Slice column direction vector Y component data, = struct.unpack('<f',\",\n \"transformation and # coregistration routines as well as for proper visualization. # Expected\",\n \"header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to write Brainvoyager VMR\",\n \"offset values for # each dimension as well as a value indicating the\",\n \"header[\\\"DimZ\\\"] f.write(struct.pack('<H', data)) # --------------------------------------------------------------------- # VMR Data # --------------------------------------------------------------------- # Convert axes\",\n \"data # 16-bit data mean intensity data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MaxValue\\\"] = data\",\n \"Guide 2.6): These four entries have been added in # file version \\\"3\\\"\",\n \"Transformation values are stored as a list trans_values = header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] for j in\",\n \"header[\\\"DimY\\\"] = data data, = struct.unpack('<H', f.read(2)) header[\\\"DimZ\\\"] = data # --------------------------------------------------------------------- #\",\n \"All other entries are # identical to file version \\\"2\\\". # Expected binary\",\n \"data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data)) # Expected binary data:\",\n \"data # Field of view extent in column dir. [mm] data, = struct.unpack('<f',\",\n \"left -> right) [axis 0 after np.reshape] = X in Tal space #\",\n \"= data # Nr of columns of slice image matrix # Expected binary\",\n \"header[\\\"RowDirZ\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirX\\\"] f.write(struct.pack('<f', data)) data = header[\\\"ColDirY\\\"] f.write(struct.pack('<f', data))\",\n \"(1 byte) data, = struct.unpack('<B', f.read(1)) header[\\\"LeftRightConvention\\\"] = data # modified in v4\",\n \"data # Expected binary data: int (4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"]\",\n \"binary data: short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data\",\n \"# iso-dimensions to which the data set will be internally \\\"expanded\\\" # for\",\n \"data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length string\",\n \"in terms of # BrainVoyager's internal format. These four entries are followed by\",\n \"read_variable_length_string(f) header[\\\"PastTransformation\\\"][i][\\\"SourceFileName\\\"] = data # Expected binary data: int (4 bytes) data, =\",\n \"axis data, = struct.unpack('<f', f.read(4)) header[\\\"VoxelSizeY\\\"] = data # Voxel resolution along Y\",\n \"max intensity return header, data_img # ============================================================================= def write_vmr(filename, header, data_img): \\\"\\\"\\\"Protocol to\",\n \"transformation\\\" is a value determining how many # subsequent values define the transformation:\",\n \"= struct.unpack('<B', f.read(1)) header[\\\"VoxelResolutionInTALmm\\\"] = data # Expected binary data: int (4 bytes)\",\n \"the whole brain (head) of subjects. The # intensity values are stored as\",\n \"BrainVoyager QX 1.7. All other entries are # identical to file version \\\"2\\\".\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PosInfosVerified\\\"] = data data, = struct.unpack('<i', f.read(4)) header[\\\"CoordinateSystem\\\"]\",\n \"f.read(4)) header[\\\"NRows\\\"] = data # Nr of rows of slice image matrix data,\",\n \"# Expected binary data: float (4 bytes) data = header[\\\"Slice1CenterX\\\"] f.write(struct.pack('<f', data)) data\",\n \"only slightly different from # version 3 (as indicated below). Version 3 added\",\n \"bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] = data # Expected binary data: variable-length\",\n \"# post-header data can be probably ignored for custom routines, but is #\",\n \"Y coordinate data, = struct.unpack('<f', f.read(4)) header[\\\"SliceNCenterZ\\\"] = data # Last slice center\",\n \"files is \\\"4\\\", which is only slightly different from # version 3 (as\",\n \"Expected binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data)) data =\",\n \"write_variable_length_string(f, data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"] f.write(struct.pack('<i',\",\n \"bvbabel.utils import (read_variable_length_string, write_variable_length_string) # ============================================================================= def read_vmr(filename): \\\"\\\"\\\"Read Brainvoyager VMR file. Parameters\",\n \"data) # Expected binary data: int (4 bytes) data = header[\\\"PastTransformation\\\"][i][\\\"Type\\\"] f.write(struct.pack('<i', data))\",\n \"Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) trans_values.append(data) header[\\\"PastTransformation\\\"][i][\\\"Values\\\"] =\",\n \"image matrix # Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4))\",\n \"::-1, ::-1] # Flip BV axes data_img = np.transpose(data_img, (0, 2, 1)) #\",\n \"in # terms of BrainVoyager's internal conventions but follow the DICOM # standard.\",\n \"3: # NOTE(Developer Guide 2.6): These four entries have been added in #\",\n \"short int (2 bytes) data, = struct.unpack('<h', f.read(2)) header[\\\"OffsetX\\\"] = data data, =\",\n \"= data # Voxel resolution along Z axis # Expected binary data: char\",\n \"along Z axis # Expected binary data: char (1 byte) data, = struct.unpack('<B',\",\n \"\\\"1\\\", file versions 2 and higher contain # additional header information after the\",\n \"(e.g. Talairach after # normalization) and voxel resolution. if header[\\\"File version\\\"] >= 3:\",\n \"QX for spatial transformation and # coregistration routines as well as for proper\",\n \"to # format 2 in order to represent large data sets efficiently, e.g.\",\n \"Y component data, = struct.unpack('<f', f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction\",\n \"(4 bytes) data, = struct.unpack('<i', f.read(4)) header[\\\"VMROrigV16MinValue\\\"] = data # 16-bit data min\",\n \"f.read(4)) header[\\\"RowDirZ\\\"] = data # Slice row direction vector Z component data, =\",\n \"f.write(struct.pack('<i', data)) data = header[\\\"CoordinateSystem\\\"] f.write(struct.pack('<i', data)) # Expected binary data: float (4\",\n \"f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterY\\\"] f.write(struct.pack('<f', data)) data = header[\\\"SliceNCenterZ\\\"] f.write(struct.pack('<f', data)) data\",\n \"Slice column direction vector Z component # Expected binary data: int (4 bytes)\",\n \"to represent large data sets efficiently, e.g. in # the context of advanced\",\n \"proper visualization. # Expected binary data: unsigned short int (2 bytes) data, =\",\n \"NOTE(Developer Guide 2.6): These four entries have been added in # file version\",\n \"axes # --------------------------------------------------------------------- # VMR Post-Data Header # --------------------------------------------------------------------- # NOTE(Developer Guide 2.6):\",\n \"= header[\\\"VMROrigV16MinValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MeanValue\\\"] f.write(struct.pack('<i', data)) data = header[\\\"VMROrigV16MaxValue\\\"] f.write(struct.pack('<i',\",\n \"header[\\\"FoVCols\\\"] = data # Field of view extent in column dir. [mm] data,\",\n \"[] for j in range(header[\\\"PastTransformation\\\"][i][\\\"NrOfValues\\\"]): # Expected binary data: float (4 bytes) data,\",\n \"axes from Nifti standard back to BV standard data_img = data_img[::-1, ::-1, ::-1]\",\n \"(0, 2, 1)) # BV to Tal # Expected binary data: unsigned char\",\n \"trans_values[j])) # Expected binary data: char (1 byte) data = header[\\\"LeftRightConvention\\\"] f.write(struct.pack('<B', data))\",\n \"# Expected binary data: float (4 bytes) data, = struct.unpack('<f', f.read(4)) header[\\\"FoVRows\\\"] =\",\n \"= data # new in v4 # Expected binary data: float (4 bytes)\"\n]","isConversational":false}}},{"rowIdx":2496,"cells":{"ngram":{"kind":"list like","value":["an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND,","distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY","print('Tested %s acc = %f, speed = %f img/sec' % (m, r, speed))","express or implied. See the License for the # specific language governing permissions","**kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec'","mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc,","m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs)","You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #","acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' % (m, r,","(the # \"License\"); you may not use this file except in compliance #","License for the # specific language governing permissions and limitations # under the","= %f, speed = %f img/sec' % (m, r, speed)) assert r >","you under the Apache License, Version 2.0 (the # \"License\"); you may not","(ASF) under one # or more contributor license agreements. See the NOTICE file","License is distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS","gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data()","this file # to you under the Apache License, Version 2.0 (the #","models \"\"\" from __future__ import print_function import mxnet as mx from common import","r, speed)) assert r > g and r < g + .1 if","software distributed under the License is distributed on an # \"AS IS\" BASIS,","law or agreed to in writing, # software distributed under the License is","acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' % (m, r,","# # Unless required by applicable law or agreed to in writing, #","= mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested","= mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus =","# software distributed under the License is distributed on an # \"AS IS\"","to you under the Apache License, Version 2.0 (the # \"License\"); you may","download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs =","['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs): acc","'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs): acc =","'__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus)","== '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 *","file # distributed with this work for additional information # regarding copyright ownership.","\"\"\" from __future__ import print_function import mxnet as mx from common import find_mxnet,","of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable","# Licensed to the Apache Software Foundation (ASF) under one # or more","Version 2.0 (the # \"License\"); you may not use this file except in","for the # specific language governing permissions and limitations # under the License.","and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m =","r, speed)) assert r > g and r < g + .1 def","under the Apache License, Version 2.0 (the # \"License\"); you may not use","mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78]","(m, r, speed)) assert r > g and r < g + .1","copyright ownership. The ASF licenses this file # to you under the Apache","ownership. The ASF licenses this file # to you under the Apache License,","License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0","data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed","print_function import mxnet as mx from common import find_mxnet, modelzoo from score import","under the License is distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES","def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs","additional information # regarding copyright ownership. The ASF licenses this file # to","License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or","BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied.","# \"License\"); you may not use this file except in compliance # with","OF ANY # KIND, either express or implied. See the License for the","or implied. See the License for the # specific language governing permissions and","metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed = %f","# Unless required by applicable law or agreed to in writing, # software","print('Tested %s, acc = %f, speed = %f img/sec' % (m, r, speed))","'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r =","= ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs):","0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s","at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed","len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500}","Licensed to the Apache Software Foundation (ASF) under one # or more contributor","**kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec'","def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g)","assert r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc","rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed =","distributed under the License is distributed on an # \"AS IS\" BASIS, WITHOUT","or more contributor license agreements. See the NOTICE file # distributed with this","','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data() test_imagenet1k_resnet(**kwargs) test_imagenet1k_inception_bn(**kwargs)","to in writing, # software distributed under the License is distributed on an","pretrained models \"\"\" from __future__ import print_function import mxnet as mx from common","r > g and r < g + .1 if __name__ == '__main__':","< g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g","agreed to in writing, # software distributed under the License is distributed on","score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f,","OR CONDITIONS OF ANY # KIND, either express or implied. See the License","Foundation (ASF) under one # or more contributor license agreements. See the NOTICE","g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1]","+ .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0","for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA,","Apache Software Foundation (ASF) under one # or more contributor license agreements. See","= [.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,)","\"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express","permissions and limitations # under the License. \"\"\" test pretrained models \"\"\" from","%s, acc = %f, speed = %f img/sec' % (m, r, speed)) assert","score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models","VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152']","a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required","find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA)","License, Version 2.0 (the # \"License\"); you may not use this file except","to the Apache Software Foundation (ASF) under one # or more contributor license","= score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc =","# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in","common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download(","g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc,","License. \"\"\" test pretrained models \"\"\" from __future__ import print_function import mxnet as","acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA,","this file except in compliance # with the License. You may obtain a","+ .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75","speed = %f img/sec' % (m, r, speed)) assert r > g and","speed)) assert r > g and r < g + .1 if __name__","r = acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' %",".1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size","in compliance # with the License. You may obtain a copy of the","implied. See the License for the # specific language governing permissions and limitations","as mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def","may not use this file except in compliance # with the License. You",".78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m,","or agreed to in writing, # software distributed under the License is distributed","in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs)","assert r > g and r < g + .1 if __name__ ==","if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size =","import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models =","use this file except in compliance # with the License. You may obtain","ASF licenses this file # to you under the Apache License, Version 2.0","metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed = %f","import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec',","rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed =","% (m, r, speed)) assert r > g and r < g +","Unless required by applicable law or agreed to in writing, # software distributed","modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def","Software Foundation (ASF) under one # or more contributor license agreements. See the","acc = %f, speed = %f img/sec' % (m, r, speed)) assert r","mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i)","distributed with this work for additional information # regarding copyright ownership. The ASF","# distributed with this work for additional information # regarding copyright ownership. The","16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus,","license agreements. See the NOTICE file # distributed with this work for additional","the License is distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR","= 16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs =","VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m,","\"License\"); you may not use this file except in compliance # with the","on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY #","g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m","zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r","regarding copyright ownership. The ASF licenses this file # to you under the","'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for","# KIND, either express or implied. See the License for the # specific","[.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) =","data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed","this work for additional information # regarding copyright ownership. The ASF licenses this","with this work for additional information # regarding copyright ownership. The ASF licenses","ANY # KIND, either express or implied. See the License for the #",".1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,)","See the NOTICE file # distributed with this work for additional information #","(m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0',","contributor license agreements. See the NOTICE file # distributed with this work for","either express or implied. See the License for the # specific language governing","(speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc","(speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc","the License. You may obtain a copy of the License at # #","copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by","mxnet as mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec'","under the License. \"\"\" test pretrained models \"\"\" from __future__ import print_function import","> g and r < g + .1 if __name__ == '__main__': gpus","= score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc =","the NOTICE file # distributed with this work for additional information # regarding","%f, speed = %f img/sec' % (m, r, speed)) assert r > g","in writing, # software distributed under the License is distributed on an #","the Apache Software Foundation (ASF) under one # or more contributor license agreements.","= 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested","# specific language governing permissions and limitations # under the License. \"\"\" test","mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data():","agreements. See the NOTICE file # distributed with this work for additional information","not use this file except in compliance # with the License. You may","from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs):","language governing permissions and limitations # under the License. \"\"\" test pretrained models","writing, # software distributed under the License is distributed on an # \"AS","r = acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' %","%s acc = %f, speed = %f img/sec' % (m, r, speed)) assert","test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in","# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to","# or more contributor license agreements. See the NOTICE file # distributed with","import mxnet as mx from common import find_mxnet, modelzoo from score import score","= %f img/sec' % (m, r, speed)) assert r > g and r","g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) >","__future__ import print_function import mxnet as mx from common import find_mxnet, modelzoo from","= mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939',","r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn'","r < g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert","g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g =","score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50',","See the License for the # specific language governing permissions and limitations #","WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the","< g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus)","NOTICE file # distributed with this work for additional information # regarding copyright","0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in gpus])","IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or","\"\"\" test pretrained models \"\"\" from __future__ import print_function import mxnet as mx","__name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16","* len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size,","2.0 (the # \"License\"); you may not use this file except in compliance","img/sec' % (m, r, speed)) assert r > g and r < g","= acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' % (m,","the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law","> 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in","batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs","# with the License. You may obtain a copy of the License at","acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1]","= ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data() test_imagenet1k_resnet(**kwargs)","models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models,","> g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc')","KIND, either express or implied. See the License for the # specific language","specific language governing permissions and limitations # under the License. \"\"\" test pretrained","accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r =","= acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' % (m,","# under the License. \"\"\" test pretrained models \"\"\" from __future__ import print_function","obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless","# regarding copyright ownership. The ASF licenses this file # to you under","the Apache License, Version 2.0 (the # \"License\"); you may not use this","Apache License, Version 2.0 (the # \"License\"); you may not use this file","mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s,","%f img/sec' % (m, r, speed)) assert r > g and r <","len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i","more contributor license agreements. See the NOTICE file # distributed with this work","accs = [.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc')","under one # or more contributor license agreements. See the NOTICE file #","the # specific language governing permissions and limitations # under the License. \"\"\"","g and r < g + .1 if __name__ == '__main__': gpus =","# to you under the Apache License, Version 2.0 (the # \"License\"); you","required by applicable law or agreed to in writing, # software distributed under","gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus","is distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF","speed)) assert r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs):","compliance # with the License. You may obtain a copy of the License","and limitations # under the License. \"\"\" test pretrained models \"\"\" from __future__","the License. \"\"\" test pretrained models \"\"\" from __future__ import print_function import mxnet","def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) =","assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for","by applicable law or agreed to in writing, # software distributed under the","= 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r","for additional information # regarding copyright ownership. The ASF licenses this file #","from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return","WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See","with the License. You may obtain a copy of the License at #","test pretrained models \"\"\" from __future__ import print_function import mxnet as mx from","information # regarding copyright ownership. The ASF licenses this file # to you","The ASF licenses this file # to you under the Apache License, Version","file except in compliance # with the License. You may obtain a copy","limitations # under the License. \"\"\" test pretrained models \"\"\" from __future__ import","test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m,","CONDITIONS OF ANY # KIND, either express or implied. See the License for","import print_function import mxnet as mx from common import find_mxnet, modelzoo from score","file # to you under the Apache License, Version 2.0 (the # \"License\");","the License for the # specific language governing permissions and limitations # under","r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc =","may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #","work for additional information # regarding copyright ownership. The ASF licenses this file","applicable law or agreed to in writing, # software distributed under the License","one # or more contributor license agreements. See the NOTICE file # distributed","and r < g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus()","except in compliance # with the License. You may obtain a copy of","governing permissions and limitations # under the License. \"\"\" test pretrained models \"\"\"","from __future__ import print_function import mxnet as mx from common import find_mxnet, modelzoo","http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,","you may not use this file except in compliance # with the License.","return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77,","licenses this file # to you under the Apache License, Version 2.0 (the","score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f,","# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either"],"string":"[\n \"an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND,\",\n \"distributed on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\",\n \"print('Tested %s acc = %f, speed = %f img/sec' % (m, r, speed))\",\n \"express or implied. See the License for the # specific language governing permissions\",\n \"**kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec'\",\n \"mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc,\",\n \"m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs)\",\n \"You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #\",\n \"acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' % (m, r,\",\n \"(the # \\\"License\\\"); you may not use this file except in compliance #\",\n \"License for the # specific language governing permissions and limitations # under the\",\n \"= %f, speed = %f img/sec' % (m, r, speed)) assert r >\",\n \"you under the Apache License, Version 2.0 (the # \\\"License\\\"); you may not\",\n \"(ASF) under one # or more contributor license agreements. See the NOTICE file\",\n \"License is distributed on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS\",\n \"gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data()\",\n \"this file # to you under the Apache License, Version 2.0 (the #\",\n \"models \\\"\\\"\\\" from __future__ import print_function import mxnet as mx from common import\",\n \"r, speed)) assert r > g and r < g + .1 if\",\n \"software distributed under the License is distributed on an # \\\"AS IS\\\" BASIS,\",\n \"law or agreed to in writing, # software distributed under the License is\",\n \"acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' % (m, r,\",\n \"# # Unless required by applicable law or agreed to in writing, #\",\n \"= mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested\",\n \"= mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus =\",\n \"# software distributed under the License is distributed on an # \\\"AS IS\\\"\",\n \"to you under the Apache License, Version 2.0 (the # \\\"License\\\"); you may\",\n \"download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs =\",\n \"['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs): acc\",\n \"'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs): acc =\",\n \"'__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus)\",\n \"== '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 *\",\n \"file # distributed with this work for additional information # regarding copyright ownership.\",\n \"\\\"\\\"\\\" from __future__ import print_function import mxnet as mx from common import find_mxnet,\",\n \"of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable\",\n \"# Licensed to the Apache Software Foundation (ASF) under one # or more\",\n \"Version 2.0 (the # \\\"License\\\"); you may not use this file except in\",\n \"for the # specific language governing permissions and limitations # under the License.\",\n \"and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m =\",\n \"r, speed)) assert r > g and r < g + .1 def\",\n \"under the Apache License, Version 2.0 (the # \\\"License\\\"); you may not use\",\n \"mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78]\",\n \"(m, r, speed)) assert r > g and r < g + .1\",\n \"copyright ownership. The ASF licenses this file # to you under the Apache\",\n \"ownership. The ASF licenses this file # to you under the Apache License,\",\n \"License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0\",\n \"data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed\",\n \"print_function import mxnet as mx from common import find_mxnet, modelzoo from score import\",\n \"under the License is distributed on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES\",\n \"def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs\",\n \"additional information # regarding copyright ownership. The ASF licenses this file # to\",\n \"License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or\",\n \"BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied.\",\n \"# \\\"License\\\"); you may not use this file except in compliance # with\",\n \"OF ANY # KIND, either express or implied. See the License for the\",\n \"or implied. See the License for the # specific language governing permissions and\",\n \"metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed = %f\",\n \"# Unless required by applicable law or agreed to in writing, # software\",\n \"print('Tested %s, acc = %f, speed = %f img/sec' % (m, r, speed))\",\n \"'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r =\",\n \"= ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models, accs):\",\n \"0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s\",\n \"at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed\",\n \"len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500}\",\n \"Licensed to the Apache Software Foundation (ASF) under one # or more contributor\",\n \"**kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec'\",\n \"def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g)\",\n \"assert r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc\",\n \"rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed =\",\n \"distributed under the License is distributed on an # \\\"AS IS\\\" BASIS, WITHOUT\",\n \"or more contributor license agreements. See the NOTICE file # distributed with this\",\n \"','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data() test_imagenet1k_resnet(**kwargs) test_imagenet1k_inception_bn(**kwargs)\",\n \"to in writing, # software distributed under the License is distributed on an\",\n \"pretrained models \\\"\\\"\\\" from __future__ import print_function import mxnet as mx from common\",\n \"r > g and r < g + .1 if __name__ == '__main__':\",\n \"< g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g\",\n \"agreed to in writing, # software distributed under the License is distributed on\",\n \"score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f,\",\n \"OR CONDITIONS OF ANY # KIND, either express or implied. See the License\",\n \"Foundation (ASF) under one # or more contributor license agreements. See the NOTICE\",\n \"g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1]\",\n \"+ .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0\",\n \"for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA,\",\n \"Apache Software Foundation (ASF) under one # or more contributor license agreements. See\",\n \"= [.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,)\",\n \"\\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express\",\n \"permissions and limitations # under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from\",\n \"%s, acc = %f, speed = %f img/sec' % (m, r, speed)) assert\",\n \"score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models\",\n \"VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152']\",\n \"a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required\",\n \"find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA)\",\n \"License, Version 2.0 (the # \\\"License\\\"); you may not use this file except\",\n \"to the Apache Software Foundation (ASF) under one # or more contributor license\",\n \"= score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc =\",\n \"# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in\",\n \"common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download(\",\n \"g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc,\",\n \"License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import print_function import mxnet as\",\n \"acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA,\",\n \"this file except in compliance # with the License. You may obtain a\",\n \"+ .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75\",\n \"speed = %f img/sec' % (m, r, speed)) assert r > g and\",\n \"speed)) assert r > g and r < g + .1 if __name__\",\n \"r = acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' %\",\n \".1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size\",\n \"in compliance # with the License. You may obtain a copy of the\",\n \"implied. See the License for the # specific language governing permissions and limitations\",\n \"as mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def\",\n \"may not use this file except in compliance # with the License. You\",\n \".78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m,\",\n \"or agreed to in writing, # software distributed under the License is distributed\",\n \"in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs)\",\n \"assert r > g and r < g + .1 if __name__ ==\",\n \"if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size =\",\n \"import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models =\",\n \"use this file except in compliance # with the License. You may obtain\",\n \"ASF licenses this file # to you under the Apache License, Version 2.0\",\n \"metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed = %f\",\n \"import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec',\",\n \"rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f, speed =\",\n \"% (m, r, speed)) assert r > g and r < g +\",\n \"Unless required by applicable law or agreed to in writing, # software distributed\",\n \"modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def\",\n \"Software Foundation (ASF) under one # or more contributor license agreements. See the\",\n \"acc = %f, speed = %f img/sec' % (m, r, speed)) assert r\",\n \"mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i)\",\n \"distributed with this work for additional information # regarding copyright ownership. The ASF\",\n \"# distributed with this work for additional information # regarding copyright ownership. The\",\n \"16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus,\",\n \"license agreements. See the NOTICE file # distributed with this work for additional\",\n \"the License is distributed on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR\",\n \"= 16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs =\",\n \"VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m,\",\n \"\\\"License\\\"); you may not use this file except in compliance # with the\",\n \"on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY #\",\n \"g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m\",\n \"zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r\",\n \"regarding copyright ownership. The ASF licenses this file # to you under the\",\n \"'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for\",\n \"# KIND, either express or implied. See the License for the # specific\",\n \"[.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) =\",\n \"data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc = %f, speed\",\n \"this work for additional information # regarding copyright ownership. The ASF licenses this\",\n \"with this work for additional information # regarding copyright ownership. The ASF licenses\",\n \"ANY # KIND, either express or implied. See the License for the #\",\n \".1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,)\",\n \"See the NOTICE file # distributed with this work for additional information #\",\n \"(m, g) in zip(models, accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0',\",\n \"contributor license agreements. See the NOTICE file # distributed with this work for\",\n \"either express or implied. See the License for the # specific language governing\",\n \"(speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s, acc\",\n \"(speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc\",\n \"the License. You may obtain a copy of the License at # #\",\n \"copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by\",\n \"mxnet as mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec'\",\n \"under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import print_function import\",\n \"> g and r < g + .1 if __name__ == '__main__': gpus\",\n \"= score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc =\",\n \"the NOTICE file # distributed with this work for additional information # regarding\",\n \"%f, speed = %f img/sec' % (m, r, speed)) assert r > g\",\n \"in writing, # software distributed under the License is distributed on an #\",\n \"the Apache Software Foundation (ASF) under one # or more contributor license agreements.\",\n \"= 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested\",\n \"# specific language governing permissions and limitations # under the License. \\\"\\\"\\\" test\",\n \"mx from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data():\",\n \"agreements. See the NOTICE file # distributed with this work for additional information\",\n \"not use this file except in compliance # with the License. You may\",\n \"from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs):\",\n \"language governing permissions and limitations # under the License. \\\"\\\"\\\" test pretrained models\",\n \"writing, # software distributed under the License is distributed on an # \\\"AS\",\n \"r = acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' %\",\n \"%s acc = %f, speed = %f img/sec' % (m, r, speed)) assert\",\n \"test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in\",\n \"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to\",\n \"# or more contributor license agreements. See the NOTICE file # distributed with\",\n \"import mxnet as mx from common import find_mxnet, modelzoo from score import score\",\n \"= %f img/sec' % (m, r, speed)) assert r > g and r\",\n \"g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) >\",\n \"__future__ import print_function import mxnet as mx from common import find_mxnet, modelzoo from\",\n \"= mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939',\",\n \"r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn'\",\n \"r < g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert\",\n \"g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g =\",\n \"score VAL_DATA='data/val-5k-256.rec' def download_data(): return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50',\",\n \"See the License for the # specific language governing permissions and limitations #\",\n \"WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the\",\n \"< g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus)\",\n \"NOTICE file # distributed with this work for additional information # regarding copyright\",\n \"0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in gpus])\",\n \"IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or\",\n \"\\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import print_function import mxnet as mx\",\n \"__name__ == '__main__': gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16\",\n \"* len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size,\",\n \"2.0 (the # \\\"License\\\"); you may not use this file except in compliance\",\n \"img/sec' % (m, r, speed)) assert r > g and r < g\",\n \"= acc.get()[1] print('Tested %s, acc = %f, speed = %f img/sec' % (m,\",\n \"the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law\",\n \"> 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in\",\n \"batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i in gpus]) kwargs\",\n \"# with the License. You may obtain a copy of the License at\",\n \"acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1]\",\n \"= ','.join([str(i) for i in gpus]) kwargs = {'gpus':gpus, 'batch_size':batch_size, 'max_num_examples':500} download_data() test_imagenet1k_resnet(**kwargs)\",\n \"models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77, .78] for (m, g) in zip(models,\",\n \"> g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc')\",\n \"KIND, either express or implied. See the License for the # specific language\",\n \"specific language governing permissions and limitations # under the License. \\\"\\\"\\\" test pretrained\",\n \"accs): acc = mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r =\",\n \"= acc.get()[1] print('Tested %s acc = %f, speed = %f img/sec' % (m,\",\n \"# under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import print_function\",\n \"obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless\",\n \"# regarding copyright ownership. The ASF licenses this file # to you under\",\n \"the Apache License, Version 2.0 (the # \\\"License\\\"); you may not use this\",\n \"Apache License, Version 2.0 (the # \\\"License\\\"); you may not use this file\",\n \"mx.metric.create('acc') (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='0,0,0', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s,\",\n \"%f img/sec' % (m, r, speed)) assert r > g and r <\",\n \"len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for i\",\n \"more contributor license agreements. See the NOTICE file # distributed with this work\",\n \"accs = [.77, .78] for (m, g) in zip(models, accs): acc = mx.metric.create('acc')\",\n \"under one # or more contributor license agreements. See the NOTICE file #\",\n \"the # specific language governing permissions and limitations # under the License. \\\"\\\"\\\"\",\n \"g and r < g + .1 if __name__ == '__main__': gpus =\",\n \"# to you under the Apache License, Version 2.0 (the # \\\"License\\\"); you\",\n \"required by applicable law or agreed to in writing, # software distributed under\",\n \"gpus = mx.test_utils.list_gpus() assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus\",\n \"is distributed on an # \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\",\n \"speed)) assert r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs):\",\n \"compliance # with the License. You may obtain a copy of the License\",\n \"and limitations # under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__\",\n \"the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import print_function import mxnet\",\n \"def test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) =\",\n \"assert len(gpus) > 0 batch_size = 16 * len(gpus) gpus = ','.join([str(i) for\",\n \"by applicable law or agreed to in writing, # software distributed under the\",\n \"= 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r\",\n \"for additional information # regarding copyright ownership. The ASF licenses this file #\",\n \"from common import find_mxnet, modelzoo from score import score VAL_DATA='data/val-5k-256.rec' def download_data(): return\",\n \"WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See\",\n \"with the License. You may obtain a copy of the License at #\",\n \"test pretrained models \\\"\\\"\\\" from __future__ import print_function import mxnet as mx from\",\n \"information # regarding copyright ownership. The ASF licenses this file # to you\",\n \"The ASF licenses this file # to you under the Apache License, Version\",\n \"file except in compliance # with the License. You may obtain a copy\",\n \"limitations # under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\" from __future__ import\",\n \"test_imagenet1k_inception_bn(**kwargs): acc = mx.metric.create('acc') m = 'imagenet1k-inception-bn' g = 0.75 (speed,) = score(model=m,\",\n \"CONDITIONS OF ANY # KIND, either express or implied. See the License for\",\n \"import print_function import mxnet as mx from common import find_mxnet, modelzoo from score\",\n \"file # to you under the Apache License, Version 2.0 (the # \\\"License\\\");\",\n \"the License for the # specific language governing permissions and limitations # under\",\n \"r > g and r < g + .1 def test_imagenet1k_inception_bn(**kwargs): acc =\",\n \"may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #\",\n \"work for additional information # regarding copyright ownership. The ASF licenses this file\",\n \"applicable law or agreed to in writing, # software distributed under the License\",\n \"one # or more contributor license agreements. See the NOTICE file # distributed\",\n \"and r < g + .1 if __name__ == '__main__': gpus = mx.test_utils.list_gpus()\",\n \"except in compliance # with the License. You may obtain a copy of\",\n \"governing permissions and limitations # under the License. \\\"\\\"\\\" test pretrained models \\\"\\\"\\\"\",\n \"from __future__ import print_function import mxnet as mx from common import find_mxnet, modelzoo\",\n \"http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,\",\n \"you may not use this file except in compliance # with the License.\",\n \"return mx.test_utils.download( 'http://data.mxnet.io/data/val-5k-256.rec', VAL_DATA) def test_imagenet1k_resnet(**kwargs): models = ['imagenet1k-resnet-50', 'imagenet1k-resnet-152'] accs = [.77,\",\n \"licenses this file # to you under the Apache License, Version 2.0 (the\",\n \"score(model=m, data_val=VAL_DATA, rgb_mean='123.68,116.779,103.939', metrics=acc, **kwargs) r = acc.get()[1] print('Tested %s acc = %f,\",\n \"# \\\"AS IS\\\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either\"\n]","isConversational":false}}},{"rowIdx":2497,"cells":{"ngram":{"kind":"list like","value":["sort the data when using TS methods. Returns ------- vDataFrame self.parent See Also","be able to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]:","the nth most occurent element. Parameters ---------- dropna: bool, optional If set to","product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See","\"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str,","the vColumn database type. \"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None):",") result = executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", )","in (\"ffill\", \"pad\")) else \" DESC\" partition_by = ( \"PARTITION BY {}\".format( \",","True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means","the vColumn using the input functions. Parameters ---------- func: list List of the","1993 the 3rd. plot_median: bool, optional If set to True, the Median will","-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) #","{}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias,","ELSE NULL END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans else:","minmax : Normalization using the MinMax (min and max). (x - min) /","{})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self, name:","== \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias]","MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({})","---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category","cot : trigonometric cotangent exp : exponential function floor : value down to","optimal If set to True, the method will return the transformation used instead","query=query, title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\", ) result =","or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also","for vColumns 1 and 2 to be used as categorical (No h will","try: parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ]","EmptyParameter( \"The parameter 'name' must not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError(","(\"dropna\", dropna, [bool])]) topk = \"\" if (k < 1) else \"LIMIT {}\".format(k)","Freedman Diaconis [2 * IQR / n ** (1 / 3)] sturges :","close_r = \"<=\", \"<\", \"[\", \"[\" if idx == 0 and include_lowest: op1,","= ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min()","aggregations to gain in performance. The catalog will be updated when the parent",") method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by =","https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\" columns = [self.alias] check","= \"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM {}\".format(","str, optional If not empty, a copy will be created using the input","self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit: str =","bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [","datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool = False,","BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in (\"mean\", \"median\") or","the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean","# \\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\","\"\"\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If the vDataFrame","used as categorical. The less frequent elements will be gathered together to create","\", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \"SELECT",") cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\",","datetime, timestamp...) or numerical. by: str, optional vColumn to use to partition the","labeled with 0 and 1 (1 meaning global outlier). \"\"\" if isinstance(method, str):","Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also --------","list, optional Labels used to name the new categories. If empty, names will","kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs):","OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]:","vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float = 4.0,","= \"density\", of: str = \"\", max_cardinality: int = 6, nbins: int =","than the upper bound to the upper bound itself. Parameters ---------- lower: float,","2, ParameterError( \"Length of parameter 'breaks' must be greater or equal to 2.\"","({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","the Random Forest model parameters used to compute the best splits when 'method'","(\"upper\", upper, [float, int])]) assert (lower != None) or (upper != None), ParameterError(","+= [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__(","\"x\"), ) ) else: for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())]","response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int,","aims to do all of the above. The idea is simple: instead of","after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\"))","IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or","------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the","import * from verticapy.errors import * ## # # __ __ ______ ______","Returns the vDataFrame memory usage. \"\"\" import sys total = ( sys.getsizeof(self) +","the MinMax (min and max). (x - min) / (max - min) by:","self.parent See Also -------- vDataFrame[].apply : Applies a function to the input vColumn.","\"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category","vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes","value of the record is greater than the threshold, it will be considered","WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\".format(","a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{}","(SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC","threshold: float, optional Uses the Gaussian distribution to define the outliers. After normalizing","elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total >","empty, an optimized number of bins will be computed. h: float, optional Interval",": Draws the histogram of the vColumn based on an aggregation. \"\"\" check_types(","result = [elem[0] for elem in result] elif self.isnum() and method in (\"same_width\",","ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, )","x: float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0]","not (method == \"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias:","AS pt_events FROM ({}) x\".format( self.alias, query, ) query = \"SELECT {} AS","vDataFrame[].apply : Applies a function to the vColumn. \"\"\" check_types( [ ( \"func\",","float, optional Uses the Gaussian distribution to identify outliers. After normalizing the data","result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])]","if self.category() == \"int\": best_h = max(math.floor(best_h), 1) return best_h # ---# def","numerical and Mode for the categorical vColumns. bfill : Back Propagation of the","the transformation used instead of the parent vDataFrame. This parameter is used for","title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name =","__getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \"vColumn doesn't","bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self,","limitations under the License. # # |_ |~) _ _| _ /~\\ _","!= None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\",","as categorical. numcol: str, optional Numerical vColumn to use when the parameter method","zscore : Normalization using the Z-Score (avg and std). (x - avg) /","p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0],","more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value","in (\"mean\", \"median\") or isinstance(val, float): category, ctype = \"float\", \"float\" elif method","1, ParameterError(\"Parameter 'n' must be greater or equal to 1\") where = \"","query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value","'{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query","computation. max_cardinality: int, optional Cardinality threshold to use to determine if the vColumn","'{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i ) for i in","{})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] =","the current vColumn and creating a copy with the specified name. \\u26A0 Warning","cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor","import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name =","\"License\"); # You may not use this file except in compliance with the","else \"\" ) upper_when = ( \"WHEN {} > {} THEN {} \".format(\"{}\",","TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans =","Returns ------- ax Matplotlib axes object \"\"\" columns = [self.alias] check = True","of the vColumn based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]),","# ---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date:",": SQL code generation will be slower if the vDataFrame has been transformed","/ / / # \\ / / / # \\_______/ / / #","Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram of the","numerical : Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality","'use_threshold' is set to False else the lower and upper ZScores. threshold: float,","trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the function has","nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)])","h = round(h, 6) if self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end","(\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else \"\" return self.aggregate(func=[prefix +","spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def","assert k >= 2, ParameterError( \"Parameter 'k' must be greater or equals to","/ / # \\ / / / # \\_______/ / / # ______","kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of points to","except Exception as e: raise QueryError( \"{}\\nError when applying the func 'x ->","Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the","def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float","\"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\",","med, mad) else: final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\", med,","sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) /","RF Regressor will be trained if the response is numerical (except ints and","+ total) / self.parent.shape()[0] ) except: pass total = int(total) conj = \"s","name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") )","= \"Can not normalize {} using a Robust Z-Score - The MAD is","order_by = [order_by] check_types( [ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\",","input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \"\"\"","\" UNION ALL \".join(query) ) title = \"Describes the statics of {} partitioned","= [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)","float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\",","[str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]),","new vDataFrame of the search. Parameters ---------- val: list List of the different",") return self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where","self.alias, self.alias, table ) result = executeSQL( query, title=\"Different aggregations to compute the","Encodes the vColumn using the mean encoding of a response. \"\"\" if self.category()","be used as categorical (No h will be picked or computed) h: float,","values will not be considered during the computation. Returns ------- tablesample An object","is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method","len(by) if self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif","Returns True if the vColumn category is date, False otherwise. Returns ------- bool","else \"NULL\", ) for elem in result if elem[2] != None ] ),","See Also -------- vDataFrame.isin : Looks if some specific records are in the","for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"]","\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM",": Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])])","check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n == 1: pre_comp =","f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\"","method: str, optional The describe method. auto : Sets the method to 'numerical'","\".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[2]","means simply not selecting it in the final generated SQL code. Note: Dropping","elif self.isnum() and method in (\"same_width\", \"auto\"): if not (h) or h <=","---# def get_dummies( self, prefix: str = \"\", prefix_sep: str = \"_\", drop_first:","type. Returns ------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype","[(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog:","# ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores all user","---# def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of","{} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def count(self): \"\"\" ---------------------------------------------------------------------------","pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality,","/ # / / # / / # \\ / # \\ /","the regular expression is in each of the vColumn records. vDataFrame[].extract : Extracts","------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","-------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns","# # # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores",") .transpose() .values[self.alias] ) result = [distinct_count] + result index = [ \"unique\",","-------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \"\"\" check_types(","Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount",") return [item for sublist in query_result for item in sublist] # ---#","return_trans: bool, optimal If set to True, the method will return the transformation","vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) +","Applies functions to the input vColumns. vDataFrame.applymap : Applies a function to all","= 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence","AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i - 1],","be picked or computed) h: float, optional Interval width of the bar. If","str = \"density\", of: str = \"\", max_cardinality: int = 6, h: float","an optimized h will be computed. pie_type: str, optional The type of pie","value at risk dtype : vColumn type iqr : interquartile range kurtosis :","drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha: float =","all_partition += [elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations)","value up to the next whole number cos : trigonometric cosine cosh :","offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited","elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column =","nbins: int, optional Maximum number of points to use to evaluate the approximate","int Start of the slicing. step: int Size of the slicing. Returns -------","-> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception as","topk = \"\" if (k < 1) else \"LIMIT {}\".format(k) dropna = \"","== \"float\"): trans = ( \"'[' || FLOOR({} / {}) * {} ||","Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias)","The vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns -------","if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model =","upper, upper) if (isinstance(upper, (float, int))) else \"\" ) func = \"(CASE {}{}ELSE","to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0,","isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise.","max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts:","is greater than the threshold, it will be considered as an outlier. use_threshold:","parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS","The category will be one of the following: date / int / float","parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias)","== \"same_freq\") or ( self.isnum() and method == \"smart\" ): n = len(result)","\"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias)","in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def","and 1 (1 meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]),","index.step in (1, None), ValueError( \"vColumn doesn't allow slicing having steps different than","vDataFrame. Dropping a vColumn means simply not selecting it in the final generated","{}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif","---------- x: float If the vColumn type is date like (date, datetime ...),","else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column]","nth_elems + [str(count)]) ) query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER","str, optional The type of pie chart. auto : Regular pie chart. donut",") assert response, ParameterError( \"Parameter 'response' can not be empty in case of","isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop -","maximum depth of 10. response: str, optional Response vColumn when method is set","[bool])]) topk = \"\" if (k < 1) else \"LIMIT {}\".format(k) dropna =","using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def","def iv_woe(self, y: str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information","the time of the learning and scoring phases. xlim: tuple, optional Set the","NameError( f\"A vColumn has already the alias of one of the dummies ({name}).\\n\"","self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0:","the input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])]) assert",") lower_when = ( \"WHEN {} < {} THEN {} \".format(\"{}\", lower, lower)","= \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {}","nth most occurent element. Parameters ---------- dropna: bool, optional If set to True,","outliers using the input method. Parameters ---------- method: str, optional Method to use","vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) #","Diaconis [2 * IQR / n ** (1 / 3)] sturges : Sturges","ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut chart","one_hot_encode = get_dummies # ---# def head(self, limit: int = 5): \"\"\" ---------------------------------------------------------------------------","if elem[2] != None ] ), ) executeSQL( \"SELECT {}, {} FROM {}","the partition. return_trans: bool, optimal If set to True, the method will return","please use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med =","kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See","See Also -------- vDataFrame[].slice : Slices the vColumn using a time series rule.","\"{}\", length, unit.upper(), start_or_end ) ) # ---# def spider( self, by: str","val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun ==","this \" \"issue.\" ) for k in range(len(distinct_elements) - n): name = (","(14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str =","the vColumn {} using the following mapping:{}\".format( self.alias, text_info ) ) return self.parent","feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes","vColumn. Parameters ---------- x: float If the vColumn type is date like (date,","vColumns are numerical. Optimized h will be computed if the parameter is empty","pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only available on type numeric|date\"","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev",": skewness sum : sum std : standard deviation topk : kth most","outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter. alpha:","one column of that relation. vColumns simplify several processes with its abstractions. Parameters","width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower()","to a specified number of decimal places sign : arithmetic sign sin :","= labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND","tablesample(values) # ---# def discretize( self, method: str = \"auto\", h: float =","conditional value at risk dtype : vColumn type iqr : interquartile range kurtosis","the # entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize","# ---# def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k","= self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality, h,","else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters =","optional Number representing the outliers threshold. Values lesser than quantile(alpha) or greater than","= [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx],","'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent and","Step Plot. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format(","in the partition. return_trans: bool, optimal If set to True, the method will","Minimum of the vColumn 'of'. max : Maximum of the vColumn 'of'. sum","do all of the above. The idea is simple: instead of moving #","empty in case of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response =","the different aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0] = (","list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot of","stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER (PARTITION","approximate cardinality is returned. By setting this parameter to False, the function's performance","the vColumn using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate","elements will be gathered together to create a new category : 'Others'. cat_priority:","model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100})","(h) or h <= 0: if nbins <= 0: h = self.numh() else:","= False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters","= model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name","self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit = 0","use to impute the vColumn. method: dict, optional Method to use to impute","\"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule. Parameters","'count' (Number of non-Missing elements). Returns ------- int number of non-Missing elements. See","apply_fun(self, func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default function","else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx,","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx)","be empty.\" ) conditions, column = [], self.alias for idx in range(len(breaks) -","by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\",","\"max_depth\": 10} to train a Random Forest with 20 trees and a maximum","xlim: xmin = self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines","return self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\") if val != None:","one element to use to order the data\" ) desc = \"\" if","with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the","---------- y: str Response vColumn. nbins: int, optional Maximum number of nbins used","\"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by)","str, optional Method to use to normalize. zscore : Normalization using the Z-Score","= 1 elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__(","= self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)): expr","name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({},","be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See","by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL(","/ self.parent.shape()[0] ) for elem in sauv: if \"top\" in elem: if \"percent\"","OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha,","fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() ==","(1, None), ValueError( \"vColumn doesn't allow slicing having steps different than 1.\" )","pie chart of the vColumn based on an aggregation. Parameters ---------- method: str,","query = \"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events","vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---#","\"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype = self.category(), self.ctype() copy_trans","\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif","a customized expression. \"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]),","function: x -> x^2 + 2 use \"POWER({}, 2) + 2\". copy_name: str,","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn","date. \"\"\" return self.category() in (\"float\", \"int\") # ---# def iv_woe(self, y: str,",") trans += \" ELSE NULL END)\" trans = (trans, \"varchar\", \"text\") if","== \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {} GROUP","Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True if the","self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \"Normalize doesn't work","vColumn {} was transformed using a mean encoding with {} as Response Column.\".format(","is simple: instead of moving # data around for processing, VerticaPy brings the","picked or computed) nbins: int, optional Number of nbins. If empty, an optimized","False, the function's performance can drastically decrease. Returns ------- float quantile (or approximate","= \"gaussian\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ):","\"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\",","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float","/ / # \\ / # \\ / # \\/ # _ #","FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE","& IV of {} (response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"]","if \"top\" in elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem","\"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n == 1: pre_comp","vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types(","expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number","query = \"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL","self.parent except Exception as e: raise QueryError( \"{}\\nError when applying the func 'x","Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode","if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop","= \"s were \" if len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__(","{\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x: float):","power or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws","( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass total =","number ln : natural logarithm log : logarithm log10 : base 10 logarithm","vColumn category is date, False otherwise. Returns ------- bool True if the vColumn","{} FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT","\"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations +=","self.alias, self.alias, n ) title = \"Reads {} {} smallest elements.\".format(n, self.alias) return","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using","optional The integer k of the 'topk' method. new_category: str, optional The name","0.000001: h = round(h, 6) if self.category() == \"int\": h = int(max(math.floor(h), 1))","= -1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent","to check if Badr and Fouad are in the vColumn. You can write","upper) if (isinstance(upper, (float, int))) else \"\" ) func = \"(CASE {}{}ELSE {}","== 0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax -","optional Number of bins. If empty, an optimized number of bins will be",") else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---#","(category in (\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category,","self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history:","when the parameter method is set to 'cat_stats'. Returns ------- tablesample An object","for elem in self.transformations] total = self.count() if method not in [\"mode\", \"0ifnull\"]:","____________ ______ # / __ `\\ / / # | \\/ / /","aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float,","= ( \"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({}","p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\"Computing","tanh : hyperbolic tangent x: int/float, optional If the function has two arguments","entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data","\"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, )","NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result] ),","---# def quantile(self, x: float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the","'same_freq'\" ) count = self.count() nb = int(float(count / int(nbins))) assert nb !=","it is part of the DB version you are using. Returns ------- tablesample","IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if","self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\"Computing the equal frequency","{} using the MIN and the MAX. MAX = MIN !\".format( self.alias )","str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0],","1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\".format( self.alias,","\"fd\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]})",") n = 1 if drop_first else 0 for k in range(len(distinct_elements) -","-------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \"\"\" check_types([(\"lower\",","LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where,","(\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by","features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns categories.","[\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\",","for elem in result if elem[1] != None ] ), ) cmax =","the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if the","Warning) elif self.isnum(): if method == \"zscore\": if n == 0: nullifzero =","of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates","Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn","to True, the Median will be drawn. ax: Matplotlib axes object, optional The","elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total)","in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and","top1 for the mode) topk_percent : kth most occurent element density unique :",": Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx,","x)) # ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn","'ts' is greater than November 1993 the 3rd. area: bool, optional If set","vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns = [ column","\"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def","database type. \"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" ---------------------------------------------------------------------------","datetime.date] = \"\", area: bool = False, step: bool = False, ax=None, **style_kwds,","labels: list, optional Labels used to name the new categories. If empty, names","if method in (\"mean\", \"median\") or isinstance(val, float): category, ctype = \"float\", \"float\"","--------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB type. \"\"\"","self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax,","time series rule. Parameters ---------- length: int Slice size. unit: str, optional Slice",") for idx, elem in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] ==","\"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the","most occurent elements. \"\"\" if \"agg\" not in kwargs: query = \"SELECT {}","elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 *","of that relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias:","{} was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \"\"\" ---------------------------------------------------------------------------","q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str,","ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot","error of the mean skewness : skewness sum : sum std : standard","input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({},","\"topk\": assert k >= 2, ParameterError( \"Parameter 'k' must be greater or equals","+ 1] ... END odd : CASE ... WHEN vColumn = argv[2 *","prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first else 0 for k in","if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n = 1","/ / # / / # / / # \\ / # \\","the histogram of the vColumn based on an aggregation. \"\"\" check_types( [ (\"by\",","= \"(CASE \" for i in range(1, n): trans += \"WHEN {} BETWEEN","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---#","self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if","* sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if \"top\" in elem:","False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie(","if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method,","self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\"","regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if","as categorical (No h will be picked or computed) ax: Matplotlib axes object,","method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method == \"auto\":","outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold,","{}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha,","limit: int, optional Number of elements to display. Returns ------- tablesample An object","), method=\"fetchall\", ) values = { \"index\": [item[0] for item in result], \"count\":","\"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception as e: raise QueryError(","to sequentialize # data transformation operations, and offers beautiful graphical options. # #","if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if","if the absolute value of the record is greater than the threshold, it","\"({} - {}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else","parameter 'name', you'll be able to solve this issue.\" ) new_vColumn = vColumn(","the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the","assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias {name}.\\nBy changing the","return trans else: self.transformations += [trans] sauv = {} for elem in self.catalog:","{} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else \"\" ) upper_when =","series rule. Parameters ---------- length: int Slice size. unit: str, optional Slice size",": Applies a function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---#","BY {}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__()","\"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method:","similar to the following: (function, type, category) parent: vDataFrame, optional Parent of the","bool, optional If set to True, the Median will be drawn. ax: Matplotlib","------- bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate :","), \"varchar\", \"text\", ) else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else:","not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0]","avg) / std robust_zscore : Normalization using the Robust Z-Score (median and mad).","elif method == \"robust_zscore\": if n > 0: warning_message = \"The method 'robust_zscore'","different aggregation. aad : average absolute deviation approx_unique : approximative cardinality count :","{} AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i -","self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be","\"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ]","= \"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {}","__nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---#","deviation topk : kth most occurent element (ex: top1 for the mode) topk_percent","utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \"\"\"","1 (1 meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\",",") elif method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\"","self, by: str = \"\", method: str = \"density\", of: str = \"\",","the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\"","self.parent.shape()[0] ) except: pass total = int(total) conj = \"s were \" if","(\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int,","\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC","= True if pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of) of =","drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not","avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ),","[int, float])]) assert x != 0, ValueError(\"Division by 0 is forbidden !\") return","Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random Forest with 20","/ n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns","vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use to partition","\".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode = get_dummies # ---# def","user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with","the record is greater than the threshold, it will be considered as an","------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the","the optimal vColumn bar width. Parameters ---------- method: str, optional Method to use","= self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of)","val: list List of the different records. For example, to check if Badr","the input vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority =",") except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return self.parent","If set to True, the information will be stored in the vDataFrame history.","'quantile'. Parameters ---------- x: float A float between 0 and 1 that represents","executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype),","of the record is greater than the threshold, it will be considered as","= \"<\", \"]\" if labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions","Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors","will be computed. pie_type: str, optional The type of pie chart. auto :","elif fun == \"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif","for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix)","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def","self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list = [], include_lowest:","of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also","to impute the vColumn. method: dict, optional Method to use to impute the","itself and the values higher than the upper bound to the upper bound","the list will be included. right: bool, optional How the intervals should be","str, optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :","--------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x: float If","()) AS pt_events FROM ({}) x\".format( self.alias, query, ) query = \"SELECT {}","the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing the distinct categories","= self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date,","# ---# def cut( self, breaks: list, labels: list = [], include_lowest: bool","0 and 1 (1 meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int,","+= [name] conj = \"s were \" if len(all_new_features) > 1 else \"","vColumn \" \"or simply because of ambiguous columns naming.\\nBy changing one of \"","Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random Forest","input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x,","op1, op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l,","\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),","1.01 / nbins if h > 0.01: h = round(h, 2) elif h","return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self):","if ((is_date) and not (method == \"categorical\")) or ( method == \"is_numeric\" ):","new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates","if total > 0: try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) +","by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\",","{}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \"SELECT","0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters","\\_______/ / / # ______ / / # \\ / / / #","\"\", prefix_sep: str = \"_\", drop_first: bool = True, use_numbers_as_suffix: bool = False,","{} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin =","the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(),","ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =","using the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from","def fillna( self, val=None, method: str = \"auto\", expr: str = \"\", by:","PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25)","\"\"\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used are","# |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # / __ `\\","= \"auto\", h: float = 0, nbins: int = -1, k: int =","optimized number of bins will be computed. h: float, optional Interval width of","if (self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct() if len(cat) == 1:","\"backfill\"): assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill then 'order_by' must","= \"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\",","the vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query =","Sets the method to 'numerical' if the vColumn is numerical , 'categorical' otherwise.","/ ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE /","breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r = \"<\", \"<=\",","({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns","-------- vDataFrame[].apply : Applies a function to the vColumn. \"\"\" check_types( [ (","vColumn to use to partition the data. h: float, optional Interval width if","\"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must be a vDataFrame column if","a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the","mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN {}","from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"]",": Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins,","None if not (result) else result[0][0] if not (dropna): n = \"\" if","Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert","was applied to the vColumn {} using the following mapping:{}\".format( self.alias, text_info )","__len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---#","/ spatial / uuid / undefined Returns ------- str vColumn category. See Also","for item in query_result] index = [\"unique\", \"count\"] + [item[0] for item in","\"''\")) ) result[idx][1] = \"NULL\" if (elem[1] == None) else str(elem[1]) new_column =","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx,","vColumn 'of'. min : Minimum of the vColumn 'of'. max : Maximum of","of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns,","# ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns -------","= [ ( \"({} - {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\"","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS","= \"s were \" if total > 1 else \" was \" if","\"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, }","specific TS field from the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]),","merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the","the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot","func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---# def","if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN","Also -------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name","of the input vColumns based on an aggregation. \"\"\" check_types( [ (\"by\", by,",") query = \"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ())","series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\"","date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn","Returns True if the vColumn is numerical. \"\"\" return self.category() == \"date\" #","optional List of the vColumns to use to sort the data when using","vColumn most occurent elements. \"\"\" if \"agg\" not in kwargs: query = \"SELECT","Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__(","input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See","can have multiple children vColumns whereas one vColumn can only have one parent.","in ffill|pad|bfill|backfill then 'order_by' must be a list of at least one element","iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins,","== None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1] == None)","to True, the record will be sliced using the floor of the slicing","from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\":","set to 'smart'. A RF Regressor will be trained if the response is","verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name =","name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp","columns += [column] if not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"]","values higher than the upper bound to the upper bound itself. Parameters ----------","method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of","(SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title =","approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie(","the vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float =",") for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT split_value,","optional Drops the first dummy to avoid the creation of correlated features. use_numbers_as_suffix:","[\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ]","executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count,","and method == \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be","gen_colors() if not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax","Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax = self.max()","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar :","!= None else \"NULL\", ) for elem in result if elem[1] != None","if n > 0: warning_message = \"The method 'robust_zscore' is available only if","data. The vColumn type must be date like (date, datetime, timestamp...) or numerical.","is returned. By setting this parameter to False, the function's performance can drastically","Parameters ---------- limit: int, optional Number of elements to display. Returns ------- tablesample","--------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If","str Function to use to transform the vColumn. abs : absolute value acos","alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the","in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{} =","will return the mode of the vColumn. Returns ------- str/float/int vColumn nth most","return self.category() in (\"float\", \"int\") # ---# def iv_woe(self, y: str, nbins: int","partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count","elements cvar : conditional value at risk dtype : vColumn type iqr :","\"\"\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression in each","{name}.\\nBy changing the parameter 'name', you'll be able to solve this issue.\" )","= self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be binary to","{};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing the","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See","BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query),","Propagation of the next element (Constant Interpolation). ffill : Propagation of the first","if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None): return pre_comp","already the alias of one of the dummies ({name}).\\n\" \"It can be the","numerical / date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length of parameter","* i] THEN argv[2 * i + 1] ... END odd : CASE","len( self.transformations ) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations","return self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count'","---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element to the","else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{},","check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() ==","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def","---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float","vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1,","new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif","return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---#","tmp_query += ( \" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None))",") top = None if not (result) else result[0][0] if not (dropna): n","vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify outliers.","Matplotlib axes object, optional The axes to plot on. **style_kwds Any optional parameter","percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS","END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ),","will filter the data when 'ts' is lesser than November 1993 the 3rd.","must be date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple","len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k","self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input","Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a response.","using 'count' (Number of non-Missing elements). Returns ------- int number of non-Missing elements.","See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \"\"\" if","set to True, the approximate median is returned. By setting this parameter to","USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category,","information will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See","suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also --------","''\", \"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\", \"text\") if (self.isnum()","bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query + rp] query","NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM","check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)),","if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return","using the input functions. Parameters ---------- func: list List of the different aggregation.","= \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r = \"<=\", \"<\",","vDataFrame[].tail : Returns the a part of the vColumn. \"\"\" return self.iloc(limit=limit) #","using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the","values will not be considered during the computation. n: int, optional Integer corresponding","Parameters ---------- limit: int, optional Number of elements to display. offset: int, optional","result] elif self.isnum() and method in (\"same_width\", \"auto\"): if not (h) or h","# ---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping","object See Also -------- vDataFrame.plot : Draws the time series. \"\"\" check_types( [","the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by = [by] check_types( [","was applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features)","vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function","to compute the best splits when 'method' is set to 'smart'. A RF","self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to normalize.\", method=\"fetchall\", ) for","str = \"\", prefix_sep: str = \"_\", drop_first: bool = True, use_numbers_as_suffix: bool","vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.","method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must be","( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr =","vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\",","self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates","self.parent See Also -------- vDataFrame.case_when : Creates a new feature by evaluating some","= int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\") else \"\" if","1], result[i] ) trans += \" ELSE NULL END)\" trans = (trans, \"varchar\",","\"_\") ) n = 1 if drop_first else 0 for k in range(len(distinct_elements)","---# def nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic","index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit","{} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\" )","Computes statistics of a numerical column for each vColumn category. In this case,","example, time = '03-11-1993' will filter the data when 'ts' is greater than","+= [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias)","mean_1_alpha, \"{}\" ) ) return self.parent # ---# def fillna( self, val=None, method:","sauv: if \"top\" in elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif","\"NULL\", elem[2] if elem[2] != None else \"NULL\", ) for elem in result","response: str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :","Parameters ---------- start: int Start of the slicing. step: int Size of the","== []: if fun == \"AVG\": val = self.avg() elif fun == \"MEDIAN\":","category, ctype = \"int\", \"bool\" else: category, ctype = self.category(), self.ctype() copy_trans =","+= [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn","( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if \"top\"","{})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x,","information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics.","# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0","< {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha = (","# VerticaPy is a Python library with scikit-like functionality for conducting # data","simplify several processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations:","--------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an aggregation. Parameters","LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} largest","nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot","to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self, start: int, step:","int = 6, nbins: int = 0, h: float = 0, ax=None, **style_kwds,","n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number","code generation will be slower if the vDataFrame has been transformed multiple times,",") for elem in result if elem[1] != None ] ), ) stddev","sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"]","current axes. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","+= [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k)","self.alias) query = \"SELECT {} AS {}, {} AS ord, {}::int AS {}","min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs, MIN({}) AS","function's performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality).","to the next whole number ln : natural logarithm log : logarithm log10","by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the","Draws the Bar Chart of vColumn based on an aggregation. \"\"\" check_types( [","= \"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn","a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode","# ---# def head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head","------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the","start_or_end ) ) # ---# def spider( self, by: str = \"\", method:","is numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is","), ) else: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias,","self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\"Computing the","element to the vColumn. Parameters ---------- x: float If the vColumn type is","if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] =","\"regr_sxy\": {}, \"regr_syy\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] #","0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop +=","# \\_______/ / / # ______ / / # \\ / / /","q quantile (ex: 50% for the median) prod : product range : difference","size unit. For example, it can be 'minute' 'hour'... start: bool, optional If","elif elem == None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] =",": Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q,","regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular","h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by =","breaks: list, labels: list = [], include_lowest: bool = True, right: bool =","vColumn. nbins: int, optional Maximum number of nbins used for the discretization (must","of ambiguous columns naming.\\nBy changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll","float]), (\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","---------- *args / **kwargs Any optional parameter to pass to the geopandas plot","vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers","{} THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\"","/ NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events","1.4826 if mad != 0: if return_trans: return \"({} - {}) / ({})\".format(self.alias,","matches for the regular expression in each record of the vColumn. The vColumn","for numerical vColumns, cast the other types to varchar. same_freq : Computes bins","\"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" ---------------------------------------------------------------------------","{} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR","self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\"Computing the","* from verticapy.toolbox import * from verticapy.errors import * ## # # __","with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\",","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0]","for elem in result if elem[2] != None ] ), ) executeSQL( \"SELECT","using the method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can not be","- len( self.transformations ) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())]","= self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT","to [0, n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame","# ---# def describe( self, method: str = \"auto\", max_cardinality: int = 6,","value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({},","int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ----------","if the vColumn is numerical or of type date like. Optimized h will","OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count","None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of the input","k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements, how","whole number cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric","\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0","cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct() if","to use to compute the aggregation. h: int/float/tuple, optional Interval width of the","+ [self.max()] elif method == \"topk\": assert k >= 2, ParameterError( \"Parameter 'k'","sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total # ---#","the vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular expression.","(upper != None), ParameterError( \"At least 'lower' or 'upper' must have a numerical","copy_name: str, optional If not empty, a copy will be created using the","of a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\",","vColumn {} named {} was added to the vDataFrame.\".format( self.alias, name ) )","Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on an","1\") where = \" WHERE {} IS NOT NULL \".format(self.alias) if (dropna) else","{} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) )","KIND, either express or implied. # See the License for the specific language","self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe","self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the input type.","h will be computed. pie_type: str, optional The type of pie chart. auto","encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label","limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters","\\/\\ \\ \\ \\ \\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\","def boxplot( self, by: str = \"\", h: float = 0, max_cardinality: int","\"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query","mode : mode (most occurent element). 0ifnull : 0 when the vColumn is","min sem : standard error of the mean skewness : skewness sum :","the regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices the","/ uuid / undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype","in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({})",": Draws the donut chart of the vColumn based on an aggregation. \"\"\"","if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format(","THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events =","you'll be able to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__(","e: raise ConversionError( \"{}\\nThe vColumn {} can not be converted to {}\".format( e,","2 to be used as categorical (No h will be picked or computed)","vColumn using 'sem' (standard error of mean). Returns ------- float sem See Also","respective average. null : Replaces the outliers by the NULL value. winsorize :","method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ],","order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] +","of the vColumn. The category will be one of the following: date /","assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be numerical\" )","of parameter 'labels' + 1 or parameter 'labels' must be empty.\" ) conditions,","vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True","number of nbins used for the discretization (must be > 1) Returns -------","---------- ts: str TS (Time Series) vColumn to use to order the data.","(1 meaning global outlier). \"\"\" if isinstance(method, str): method = method.lower() check_types( [","= method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool():","in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies(","Interval width if the vColumn is numerical or of type date like. Optimized","using the Z-Score (avg and std). (x - avg) / std robust_zscore :","0: if nbins <= 0: h = self.numh() else: h = (self.max() -","method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category()","optimized histogram nbins using Random Forest.\", method=\"fetchall\", ) result = [elem[0] for elem","/ {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else: final_transformation",": Returns the head of the vColumn. vDataFrame[].tail : Returns the tail of",": median absolute deviation max : maximum mean : average median : median","Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool","\"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem in catalog: self.catalog[elem] =","date like. Optimized h will be computed if the parameter is empty or","when 'method' is set to 'smart'. A RF Regressor will be trained if","\"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str, optional","tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM","dropping the current vColumn and creating a copy with the specified name. \\u26A0","str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn.","BETWEEN {} AND {}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\"","cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers","\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else:","lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution to define","parameter method is set to 'cat_stats'. Returns ------- tablesample An object containing the","self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name: str","the vColumn to the input type. Parameters ---------- dtype: str New type. Returns","for item in query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False )","\"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method =","categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info","str = \"\", max_cardinality: int = 6, nbins: int = 0, h: float","and transforms the vColumn using a time series rule. Parameters ---------- length: int","empty, an optimized number of nbins will be computed. h: float, optional Interval","upper_when = ( \"WHEN {} > {} THEN {} \".format(\"{}\", upper, upper) if","and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must","for category in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count,","\"text\") if return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for","vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate :","sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns","= \"The method 'robust_zscore' is available only if the parameter 'by' is empty\\nIf","by the input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame","vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {}","\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()),","FLOOR({} / {}) * {} || ';' || (FLOOR({} / {}) * {}","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias,","nth_elems = nb, [], [] while total < int(float(count / int(nbins))) * int(nbins):","{})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws","set to False else the lower and upper ZScores. threshold: float, optional Uses","TS field from the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\",","input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The","NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT {} AS {}, COUNT(*) AS","title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def","represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter","to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object See","customized expression. \"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\",","and the min sem : standard error of the mean skewness : skewness","top = None if not (result) else result[0][0] if not (dropna): n =","else \"NULL\", ) for elem in result if elem[1] != None ] ),","\"\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor","of bins. If empty, an optimized number of bins will be computed. h:","== \"mean\": query = \"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({})","== \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert","self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by","{op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN",") setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features +=","- 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also","See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers :","\\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-. \\ #","of the first element (Constant Interpolation). mean : Average. median : median. mode","] ), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{},","method in (\"same_width\", \"auto\"): if not (h) or h <= 0: if nbins","current vColumn and creating a copy with the specified name. \\u26A0 Warning :","trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential","20 trees and a maximum depth of 10. response: str, optional Response vColumn","{}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else: warning_message = \"Can","0: column = args[0] elif \"column\" in kwargs: column = kwargs[\"column\"] else: check","by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by =","method: str, optional Method to use to normalize. zscore : Normalization using the","= \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method ==","int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025)","for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] =","AVG(column1) + 5). of: str, optional The vColumn to use to compute the","== None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format(","a function to the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\",","(isinstance(upper, (float, int))) else \"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when,","{})\".format( self.alias, \", \".join(by) ), ) else: avg, stddev = ( \"AVG({}) OVER","Size of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :","/ self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) )","will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills",") return top # ---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the","argv: object Any amount of expressions. The expression generated will look like: even:","\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, )","NOT NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n )","func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception as e: raise QueryError( \"{}\\nError","to partition the data. h: float, optional Interval width if the vColumn is","NULL END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations","self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset","Micro Focus or one of its affiliates. # Licensed under the Apache License,","discretization (must be > 1) k: int, optional The integer k of the","Draws the range plot of the vColumn. The aggregations used are the median","method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]),","will be sliced using the floor of the slicing instead of the ceiling.","values used to cut the vColumn. labels: list, optional Labels used to name","= gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp =","set to True, NULL values will not be considered during the computation. n:","Parameters ---------- to_replace: str Regular expression to replace. value: str, optional New value.","breaks: list List of values used to cut the vColumn. labels: list, optional","LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER","tuple = None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot.","NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result =","# Special Methods # # ---# def __init__( self, alias: str, transformations: list","by: str = \"\", h: float = 0, max_cardinality: int = 8, cat_priority:",") else: final_transformation = [ ( \"({} - {}) / {}({})\".format( \"{}\", avg,","# ---# def nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","\"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem","of the list will be included. right: bool, optional How the intervals should","FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \" WHERE","data. # # # Modules # # Standard Python Modules import math, re,","[by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans,","re, decimal, warnings, datetime from collections.abc import Iterable from typing import Union #","- sauv[\"min\"] ) except: pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"]","threshold it will be considered as an outlier. use_threshold: bool, optional Uses the","approx, [bool]))]) prefix = \"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x","range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) #","chart. rose : Rose chart. It can also be a cutomized aggregation (ex:","discretization using the method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can not","\\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\","= RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try:","more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","= 6, nbins: int = 0, h: float = 0, ax=None, **style_kwds, ):","filled.\") self.transformations = [elem for elem in copy_trans] for elem in sauv: self.catalog[elem]","\"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method ==","\"''\")) ) # ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number","category is date, False otherwise. Returns ------- bool True if the vColumn category","draw an Area Plot. step: bool, optional If set to True, draw a","Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman","{} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column =","Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn.","\"\", return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the","query, title=\"Computing the top{} categories of {}.\".format( k if k > 0 else","\"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values: for i in","\"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] +=","November 1993 the 3rd. plot_median: bool, optional If set to True, the Median","get the median). It can also be a cutomized aggregation (ex: AVG(column1) +","use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1],","\"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) ) query =","= True, right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using","statistical information. Parameters ---------- k: int, optional Number of most occurent elements to","max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in","all user transformations. If the vDataFrame represents the entire relation, a vColumn can","be equal to the length of parameter 'labels' + 1 or parameter 'labels'","\"\"\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by]","type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad","spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) #","else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND {column} {op2}","\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name,","self, prefix: str = \"\", prefix_sep: str = \"_\", drop_first: bool = True,","Fills missing elements in the vColumn with a user-specified rule. Parameters ---------- val:","n ) title = \"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title)","*argv)) # ---# def density( self, by: str = \"\", bandwidth: float =","bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also --------","the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies","------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() -","under the Apache License, Version 2.0 (the \"License\"); # You may not use","vDataFrame by using an advanced analytical function on a specific vColumn. \"\"\" return","final_transformation = [ ( \"({} - {}) / {}({} - {})\".format( \"{}\", cmin,","more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\" columns","an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of,","or (method == \"categorical\") ): query = \"\"\"(SELECT {0} || '', COUNT(*) FROM","with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes","if self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum():","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the","ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =","occurent elements to return. dropna: bool, optional If set to True, NULL values","variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info =","vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use","elif \"column\" in kwargs: column = kwargs[\"column\"] else: check = False if check:","func.replace(\"{}\", \"x\"), ) ) else: for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(),","ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \"\", h: float","n, [int, float])]) query = \"SELECT * FROM {} WHERE {} IS NOT","be used as categorical (No h will be picked or computed) ax: Matplotlib","count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min)","lesser than November 1993 the 3rd. end_date: str / date, optional Input End","regular expression in each record of the vColumn. The vColumn will be transformed.","True, draw an Area Plot. step: bool, optional If set to True, draw","(nullifzero) else \"\", cmax, cmin, ) else: final_transformation = [ ( \"({} -","optional List of the different categories to consider when drawing the box plot.","vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start,","Drops the vColumn from the vDataFrame. Dropping a vColumn means simply not selecting","AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4}","= 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if","set to True, the record will be sliced using the floor of the","(\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] )","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns -------","self.parent.shape()[0] ) for elem in sauv: if \"top\" in elem: if \"percent\" in","parameter will increase the precision but will also increase the time of the","the outliers. After normalizing the data (Z-Score), if the absolute value of the","the record will be sliced using the floor of the slicing instead of","when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest","optional parameter to pass to the geopandas plot function. For more information, see:","import pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds,","new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {} AS ord,","(SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT","bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input","func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat: str):","Parameters ---------- approx: bool, optional If set to True, the approximate median is","---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns","text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements))","n smallest elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns",") ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format( self.alias, dtype","min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {})","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"variance\"]).values[self.alias][0] variance = var","the vColumn DB type. Returns ------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower()","str = \"auto\", h: float = 0, nbins: int = -1, k: int","check_types( [ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\",","vColumn {} has no mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message,","== \"auto\": method = \"mean\" if (self.isnum() and self.nunique(True) > 6) else \"mode\"","[bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self,","= \"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN {} >","Dictionary of the Random Forest model parameters used to compute the best splits","categorical. The less frequent elements will be gathered together to create a new",": natural logarithm log : logarithm log10 : base 10 logarithm mod :","pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return self.parent # ---#","itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper bound.","to determine if the vColumn will be considered as categorical. numcol: str, optional","- 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2,","columns = [self.alias] check = True if len(args) > 0: column = args[0]","if not (\"legend\" in kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in kwargs):","'breaks' must be greater or equal to 2.\" ) assert len(breaks) == len(labels)","(\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut = True if pie_type ==","the vColumn using a time series rule. Parameters ---------- length: int Slice size.","index_stop - index_start if limit <= 0: limit = 0 limit = \"","(Time Series) vColumn to use to order the data. The vColumn type must","moving # data around for processing, VerticaPy brings the logic to the data.","chart of the vColumn based on an aggregation. Parameters ---------- method: str, optional","n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters","parameter 'breaks' must be greater or equal to 2.\" ) assert len(breaks) ==","of the different transformations. Each transformation must be similar to the following: (function,","optional Number of bins used for the discretization (must be > 1) k:","\"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2], 3)) for item in result],","result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0],","float]), (\"h\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)","except: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","the vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount of","mean : Average. median : median. mode : mode (most occurent element). 0ifnull",") # ---# def spider( self, by: str = \"\", method: str =","try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}',","\"\", method: str = \"density\", of: str = \"\", max_cardinality: Union[int, tuple] =","check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method","to use to order the data\" ) desc = \"\" if (method in",") if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\")","method == \"auto\": method = \"mean\" if (self.isnum() and self.nunique(True) > 6) else","'of'. sum : Sum of the vColumn 'of'. q% : q Quantile of","best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if","# ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns -------","the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax","): \"\"\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by:","mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\"","int, float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from","by applicable law or agreed to in writing, software # distributed under the","kernel. kernel: str, optional The method used for the plot. gaussian : Gaussian","{} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different",") elif self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS","to keep after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply","pass elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0], \",","if drop_first else 0 for k in range(len(distinct_elements) - n): name = (","methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn","---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns -------","in case of discretization using the method 'smart'.\" ) assert response, ParameterError( \"Parameter","= \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT","\"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"] =","the different transformations. Each transformation must be similar to the following: (function, type,","If set to True, the Median will be drawn. ax: Matplotlib axes object,","of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","Returns ------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype #","method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import","print(\"The mean encoding was successfully done.\") return self.parent # ---# def median( self,","/ int / float / text / binary / spatial / uuid /","0: index += self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET {} LIMIT","int, optional Number of bins. If empty, an optimized number of bins will","\"Parameter 'nbins' must be greater or equals to 2 in case of discretization",") order_by_ts = \", \".join([quote_ident(column) + desc for column in order_by]) new_column =","to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\",","+ ({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a","to_tablesample(query, title=title) # ---# def normalize( self, method: str = \"zscore\", by: list","the median and two input quantiles. Parameters ---------- ts: str TS (Time Series)","mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame","int, optional Number of most occurent elements to return. dropna: bool, optional If","graphical options. # # VerticaPy aims to do all of the above. The","= [], order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in","[(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed","argv[2 * i] THEN argv[2 * i + 1] ... ELSE argv[n] END","selecting it in the final generated SQL code. Note: Dropping a vColumn can","otherwise. expr: str, optional SQL expression. by: list, optional vColumns used in the","fun = \"MEDIAN\" if (method == \"median\") else \"AVG\" if by == []:","vColumn DB type. Returns ------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype","] ) method = method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError( \"The","total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except:","best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool =","store usage (unit: b). Returns ------- int vColumn expected store usage. See Also","get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format( self.alias,","upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers","the computation. n: int, optional Integer corresponding to the offset. For example, if","# ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr]","return self.parent # ---# def fillna( self, val=None, method: str = \"auto\", expr:","if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] #","a part of the vColumn (delimited by an offset and a limit). Parameters","): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional","AS woe, CASE WHEN non_events = 0 OR events = 0 THEN 0","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---#","*args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs","-------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \"\"\" if","The method to use to aggregate the data. count : Number of elements.","to False, the function's performance can drastically decrease. Returns ------- float quantile (or","2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) **","[float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import","an aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method,","# ---# def topk(self, k: int = -1, dropna: bool = True): \"\"\"","optimised interval will be computed. nbins: int, optional Number of bins used for","Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the","a part of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist( self,","+ 1) query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(),",") if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {}","str): val = val.replace(\"'\", \"''\") if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\",","category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will be","the vColumn is numerical. \"\"\" return self.category() == \"date\" # ---# def isin(self,","its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List of","FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS","Fills the vColumn outliers using the input method. \"\"\" check_types([(\"lower\", lower, [float, int]),","the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{} AS","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns -------",": Mean for the numerical and Mode for the categorical vColumns. bfill :","item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] +=","the following: CENTURY / DAY / DECADE / DOQ / DOW / DOY","plot. The other categories will be filtered. ax: Matplotlib axes object, optional The","the kernel. kernel: str, optional The method used for the plot. gaussian :","else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates","\"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional","SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE {0} IS NOT","the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See Also","import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds,","= pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int,","a Python library with scikit-like functionality for conducting # data science projects on","\"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x: float","vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, )","the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage","limit: int, optional Number of elements to display. offset: int, optional Number of","self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers","(IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y)","({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\",","by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def","/ WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice :","the vColumn outliers. mean : Replaces the upper and lower outliers by their","DB version you are using. Returns ------- tablesample An object containing the result.","topk : kth most occurent element (ex: top1 for the mode) topk_percent :","may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #","\"''\") if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column","---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode","float, optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent","float])]) assert x != 0, ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{}","-------- vDataFrame.isin : Looks if some specific records are in the vDataFrame. \"\"\"","method = method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int,","return self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial","or of type date like. Optimized h will be computed if the parameter","column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs): from verticapy.plot","h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis","Parameters ---------- by: str, optional vColumn to use to partition the data. method:","Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def","during the computation. cat_stats : Computes statistics of a numerical column for each","# ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to","distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool():","k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func,","Maximum number of nbins used for the discretization (must be > 1) Returns","sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See","response, ParameterError( \"Parameter 'response' can not be empty in case of discretization using","0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self,","\\_/|_|(_||| # / # ____________ ______ # / __ `\\ / / #","10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int,","only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr","discretization\" ) total, query, nth_elems = nb, [], [] while total < int(float(count","with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode :","and method == \"same_freq\") or ( self.isnum() and method == \"smart\" ): n","not normalize {} using a Robust Z-Score - The MAD is null !\".format(","VerticaPy aims to do all of the above. The idea is simple: instead",": Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] #","uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful","that stores all user transformations. If the vDataFrame represents the entire relation, a","and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha","be > 1) Returns ------- tablesample An object containing the result. For more","[ (\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date,","to 2 in case of discretization using the method 'same_freq'\" ) count =","new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn {}","places sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic sine","of the above. The idea is simple: instead of moving # data around","dict, optional Catalog where each key corresponds to an aggregation. vColumns will memorize","CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i +","drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if","int, optional Maximum number of points to use to evaluate the approximate density","str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies","== \"date\" # ---# def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if","method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method == \"median\") else","allow slicing having steps different than 1.\" ) index_stop = index.stop index_start =","result except: model.drop() raise # ---# def describe( self, method: str = \"auto\",","relevant interval to use for the discretization. topk : Keeps the topk most","try: result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format(","______ # / __ `\\ / / # | \\/ / / /","def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise.","the min sem : standard error of the mean skewness : skewness sum","max_cardinality + 1) query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format(","vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return","and 1 that represents the quantile. For example: 0.25 represents Q1. approx: bool,","data when 'ts' is greater than November 1993 the 3rd. plot_median: bool, optional","percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias,","\\/ / / / # |______ / / / # |____/ / /","): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ----------","an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\",","self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\"Different aggregations",") ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations)","Replaces the outliers by the NULL value. winsorize : Clips the vColumn using","---------- limit: int, optional Number of elements to display. offset: int, optional Number","+ \".\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self, limit:","\"_\") if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n =","vColumn and it returns the new vDataFrame of the search. Parameters ---------- val:","text_info = \"\\n\" for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"),","\"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if","use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\",","this case, the parameter 'numcol' must be defined. numerical : Uses popular numerical","to return. dropna: bool, optional If set to True, NULL values will not","null : Replaces the outliers by the NULL value. winsorize : Clips the","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness","\"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [","uuid / undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype :","False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ----------","isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of, [str]),","self.apply(func=func) return self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","\"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means simply","or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See Also","ParameterError( \"Parameter 'nbins' must be greater or equals to 2 in case of","expressions. The expression generated will look like: even: CASE ... WHEN vColumn =","vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if self.category() == \"float\" else \"\"","Average of the vColumn 'of'. min : Minimum of the vColumn 'of'. max","of the vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn.","\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT","vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def __len__(self): return","= breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r = \"<\",","vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation","to train a Random Forest with 20 trees and a maximum depth of","self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return parent","the max and the min sem : standard error of the mean skewness","BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self):","FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result =","+= [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"),",") index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start =","warnings.warn(warning_message, Warning) return self elif n == 1: try: result = executeSQL( \"SELECT","the different categories to consider when drawing the box plot. The other categories","\", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"]","drastically decrease. Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate","# ---# def quantile(self, x: float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates","an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality,","= {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True","NULL values will not be considered during the computation. n: int, optional Integer","---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns -------","mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =","== \"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for","empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns","range(1, n): trans += \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \".format(","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool","______ / / # \\ / / / # \\ / / /","vDataFrame.topk : Returns the vColumn most occurent elements. \"\"\" if \"agg\" not in","keep after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :",") return store_usage # ---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if","for testing to be able to look at the final transformation. Returns -------","the distribution. mean : Average of the vColumn 'of'. min : Minimum of","often they occur, and other statistical information. Parameters ---------- k: int, optional Number","empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to","model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---#","speed and built-in analytics and machine learning features. It supports the # entire","optional vColumn to use to partition the TS. start_date: str / date, optional","------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the","== len(labels) + 1 or not (labels), ParameterError( \"Length of parameter breaks must","vColumn by transforming the values lesser than the lower bound to the lower","case, the parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations","else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\":","SQL code generation will be slower if the vDataFrame has been transformed multiple","int, optional Maximum number of vColumn distinct elements to be used as categorical.","query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist","--------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int, optional Offset.",": cube root ceil : value up to the next whole number cos","Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed under the","\"\"), func.replace(\"{}\", \"x\"), ) ) else: for k in range(max_floor): self.transformations += [(\"{}\",","lowest element of the list will be included. right: bool, optional How the","name: str Name of the copy. Returns ------- vDataFrame self.parent See Also --------","max). (x - min) / (max - min) by: list, optional vColumns used","# \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # #","HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS","ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---#","{} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg,","alias {name}.\\nBy changing the parameter 'name', you'll be able to solve this issue.\"","------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes","date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks' must","\"approx_75%\", \"max\", ] if method != \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"]","\"median\") else \"AVG\" if by == []: if fun == \"AVG\": val =","this parameter is equal to 0, an optimised interval will be computed. nbins:","{} must be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert","datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ),","use to partition the data. bandwidth: float, optional The bandwidth of the kernel.","NOT NULL \".format(self.alias) if (dropna) else \" \" result = executeSQL( \"SELECT {}","It is only valid if the vColumns are numerical. Optimized h will be",") query_result = executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", )","- total) except Exception as e: self.transformations = [elem for elem in copy_trans]","self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None):","{}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {},","Uses the Gaussian distribution to define the outliers. After normalizing the data (Z-Score),","specific language governing permissions and # limitations under the License. # # |_","parent # ---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by","{} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT","the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp !=","aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]),","response: str = \"\", return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the","= False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method.","\"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ],","Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result","and upper ZScores. threshold: float, optional Uses the Gaussian distribution to define the","if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if","\\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/","parameter 'x' will represent the number of seconds, otherwise it will represent a","alpha: float, optional Number representing the outliers threshold. Values lesser than quantile(alpha) or","the threshold instead of the 'alpha' parameter. alpha: float, optional Number representing the","\"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\",","y: str Response vColumn. nbins: int, optional Maximum number of nbins used for","= 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna:","/ / # \\/ / / # / / # / / #","int = 6, h: float = 0, pie_type: str = \"auto\", ax=None, **style_kwds,","sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root","method: str, optional Method to use to compute the optimal h. auto :","try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop()","vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If the","use to partition the data. method: str, optional The method to use to","---------- alias: str vColumn alias. transformations: list, optional List of the different transformations.","val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\"","float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\",","number of the vColumn distinct elements to be used as categorical (No h","func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace: str, value: str","(\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by)","vColumn will be transformed. Parameters ---------- field: str The field to extract. It","[int, float]), ] ) if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr","taking advantage Vertica’s # speed and built-in analytics and machine learning features. It","of the merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary","'upper' must have a numerical value\" ) lower_when = ( \"WHEN {} <","{2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE","the vColumn type is date like (date, datetime ...), the parameter 'x' will","[ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]),","False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters","None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join(","vColumn using 'median'. Parameters ---------- approx: bool, optional If set to True, the","), title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\":","check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def","the function: x -> x^2 + 2 use \"POWER({}, 2) + 2\". copy_name:","matches in each of the vColumn records by an input value. \"\"\" check_types([(\"start\",","if Badr and Fouad are in the vColumn. You can write the following","for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({})","[int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\",","Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history,","h = (self.max() - self.min()) * 1.01 / nbins if h > 0.01:","0 else \"\", self.alias ), method=\"fetchall\", ) values = { \"index\": [item[0] for","assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill then 'order_by' must be","(\"return_trans\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero,","values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val","vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \"\"\" check_types([(\"n\", n,",": kth most occurent element density unique : cardinality (count distinct) var :","\"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method ==",": Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name =","= 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%',","transforming the values lesser than the lower bound to the lower bound itself","= result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\") and (numcol != \"\"):","the License for the specific language governing permissions and # limitations under the","is available only if the parameter 'by' is empty\\nIf you want to normalize","[ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(",") self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\",","= int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total) /","the data when using TS methods. Returns ------- vDataFrame self.parent See Also --------","vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns the tail","(numcol), ParameterError( \"The parameter 'numcol' must be a vDataFrame column if the method","transformed. Parameters ---------- field: str The field to extract. It must be one","an outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter.","the vColumns are numerical. Optimized h will be computed if the parameter is","\"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self,","be greater or equal to 1\") where = \" WHERE {} IS NOT",": Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn","print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]:","apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(),","If this parameter is equal to 0, an optimised interval will be computed.","is numerical. \"\"\" return self.category() == \"date\" # ---# def isin(self, val: list,","\"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label","!= 0, ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x))","like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2","as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set","= method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must","\".format(self.alias) if (dropna) else \" \" result = executeSQL( \"SELECT {} FROM (SELECT","by: str, optional vColumn to use to partition the data. method: str, optional","color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\",","method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply(","{} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method:","vColumn type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index","\"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory usage","= 1 then this method will return the mode of the vColumn. Returns","1] ... END odd : CASE ... WHEN vColumn = argv[2 * i]","+= \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i -","n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\")",") except: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \",","Returns ------- tablesample An object containing the result. For more information, see utilities.tablesample.","return self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad'","TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice","the n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT","bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ----------","assert nb != 0, Exception( \"Not enough values to compute the Equal Frequency","x\".format( self.alias, query, ) query = \"SELECT {} AS index, non_events, events, pt_non_events,","= \"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events =","the mean encoding of a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"),","== \"int\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx:","= \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >=","/ sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"])","\"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except:","h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut = True","(method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must be a vDataFrame","---# def drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from","the head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self,","\"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\")","the floor of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent","str = \"auto\", expr: str = \"\", by: list = [], order_by: list","\"The parameter 'name' must not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A","--------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique... depending","= \"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0","--------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means simply not","Vertica’s # speed and built-in analytics and machine learning features. It supports the","breaks[idx + 1] if right: op1, op2, close_l, close_r = \"<\", \"<=\", \"]\",","\"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {} GROUP BY {};\".format( by[0], fun,","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def","Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\", y,","{} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] +=","None else \"NULL\", ) for elem in result if elem[2] != None ]","on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","length, unit.upper(), start_or_end ) ) # ---# def spider( self, by: str =","dtype : vColumn type iqr : interquartile range kurtosis : kurtosis jb :","WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns","{} BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i],","str = \"auto\", max_cardinality: int = 6, numcol: str = \"\" ): \"\"\"","self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function to","method = method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol'","instead of moving # data around for processing, VerticaPy brings the logic to","# ---# def hist( self, method: str = \"density\", of: str = \"\",","FROM ({}) x ORDER BY ord\".format( self.alias, query, ) title = \"Computing WOE","aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements to be","ctype = \"int\", \"bool\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem","specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self,","The type of pie chart. auto : Regular pie chart. donut : Donut","\"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q:","following: CENTURY / DAY / DECADE / DOQ / DOW / DOY /","datetime from collections.abc import Iterable from typing import Union # VerticaPy Modules import","COUNT(*) AS count\" \" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY","0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can","str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will",": remainder of a division operation pow : number raised to the power","GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query,","list, optional vColumns used in the partition. return_trans: bool, optimal If set to","str / date, optional Input End Date. For example, time = '03-11-1993' will","are numerical. Optimized h will be computed if the parameter is empty or","except Exception as e: raise ConversionError( \"{}\\nThe vColumn {} can not be converted","catalog will be updated when the parent vDataFrame is modified. Attributes ---------- alias,","float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","of the vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also","(\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]),",") cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\",","vColumns whereas one vColumn can only have one parent. catalog: dict, optional Catalog","self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\".format(","{} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {}","skewness # ---# def slice(self, length: int, unit: str = \"second\", start: bool","IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) ) query = \"SELECT {}",") elif method == \"mean\": query = \"WITH vdf_table AS (SELECT * FROM","True if the vColumn is numerical, False otherwise. Returns ------- bool True if","If set to True, the approximate cardinality is returned. By setting this parameter","[(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method ==","replace. value: str, optional New value. Returns ------- vDataFrame self.parent See Also --------","\"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] /","\"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]),","== \"minmax\": if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\",","{} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", )","is numerical or of type date like. Optimized h will be computed if","{} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({})","method = method.lower() if self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if","float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut = True if pie_type","(or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","{} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query","(\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\",","type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{} AS {} FROM","vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True,","f\"A vColumn has already the alias of one of the dummies ({name}).\\n\" \"It","an Area Plot. step: bool, optional If set to True, draw a Step","AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias,","med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans:","\"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {},","def nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements","BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \"","vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn","Forest model parameters used to compute the best splits when 'method' is set","an input value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular","def apply_fun(self, func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default","\"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool, optional","else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str): \"\"\"","= ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], )","{}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL(","= int(total) conj = \"s were \" if total > 1 else \"","and 2 bars. It is only valid if the vColumns are numerical. Optimized","and not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"]","aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int,","vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a time","language governing permissions and # limitations under the License. # # |_ |~)","Returns the vColumn DB type. Returns ------- str vColumn DB type. \"\"\" return","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the","[column] if not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0]","+ 1] Returns ------- float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\",","------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","check_types( [ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\",","function's performance can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate","\"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype: str","float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]), ] ) if of:","percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS","interval size to convert to use to convert the vColumn. If this parameter","in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches","/ / # / / # \\ / # \\ / # \\/","scikit-like functionality for conducting # data science projects on data stored in Vertica,","categories to [0, n - 1] (n being the vColumn cardinality). Returns -------","assert self.parent[response].isnum(), TypeError( \"The response column must be numerical to use a mean","---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float","5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn","str = \"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the","NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None","vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk","next element (Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation).",": Replaces the outliers by the NULL value. winsorize : Clips the vColumn","elements for vColumns 1 and 2 to be used as categorical (No h","ParameterError( \"The parameter 'numcol' must be a vDataFrame column if the method is","Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the","quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See","PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i )","\"label_encode is only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements =","] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return","optional Number of most occurent elements to return. Returns ------- tablesample An object","of a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---#","/ **kwargs Any optional parameter to pass to the geopandas plot function. For","tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---#","= std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store","Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to","the offset. For example, if n = 1 then this method will return","if k > 0 else \"\", self.alias ), method=\"fetchall\", ) values = {","'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query","to solve this \" \"issue.\" ) for k in range(len(distinct_elements) - n): name","self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\"Computing the top{}","if (self.category() == \"int\") else \"\" if (h > 1) or (self.category() ==","isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method:","Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\"))","not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias of one of the","numerical vColumns, cast the other types to varchar. same_freq : Computes bins with","of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\",","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns","return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x: float): \"\"\"","kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing the distinct categories of","nbins will be computed. h: float, optional Interval width of the bar. If","when applying the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"',","\\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object","idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if","it. This parameter is very useful for testing to be able to look","---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float","to draw the Plot. start_date: str / date, optional Input Start Date. For","return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna: bool","was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{}","__ __ __ __ __ # /\\ \\ / / /\\ ___\\ /\\","between the max and the min sem : standard error of the mean","(dropna) else \" \" result = executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*)","method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =",") start_or_end = \"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}',","= avg # ---# def bar( self, method: str = \"density\", of: str","Draws the histogram of the vColumn based on an aggregation. Parameters ---------- method:","numerical, False otherwise. Returns ------- bool True if the vColumn is numerical. See","not be considered during the computation. Returns ------- tablesample An object containing the","\"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn","a limit). Parameters ---------- limit: int, optional Number of elements to display. offset:","distinct elements for vColumns 1 and 2 to be used as categorical (No","[list]), (\"return_trans\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","the parameter 'by' is empty\\nIf you want to normalize by grouping by elements,","parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return parent #","must be composed of two flower brackets {}. For example to apply the","# ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field","issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed","other statistical information. Parameters ---------- k: int, optional Number of most occurent elements","== \"categorical\") ): query = \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP","\" WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT","else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return","store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns -------","xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param","import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in kwargs): from verticapy.plot","Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by = [by] check_types(","an optimized number of bins will be computed. h: float, optional Interval width","be composed of two flower brackets {}. For example to apply the function:","functions to the input vColumns. vDataFrame.applymap : Applies a function to all the","[str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements","columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func 'x ->","str / date, optional Input Start Date. For example, time = '03-11-1993' will","= executeSQL( query, title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\", ) count,","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] #",") title = \"Computing WOE & IV of {} (response = {}).\".format(self.alias, y)","\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS","OF ANY KIND, either express or implied. # See the License for the","range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv","by, [str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h,","= (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\",","Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","numerical column for each vColumn category. In this case, the parameter 'numcol' must","str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if","nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or equals to 2","BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn",") for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if","step: int Size of the slicing. Returns ------- vDataFrame self.parent See Also --------","Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate :","|______ / / / # |____/ / / # _____________ / / #","self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ),","6, nbins: int = 0, h: float = 0, ax=None, **style_kwds, ): \"\"\"","\"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({} / {})","corresponding to the offset. For example, if n = 1 then this method","[val] val += list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val} return self.parent.isin(val)","rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by: str","used for the discretization (must be > 1) k: int, optional The integer","else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] )","the vColumn. Parameters ---------- x: float If the vColumn type is date like","method=\"fetchall\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name,","= \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =","{} IS NOT NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT {} AS",": Converts the vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try:","using 'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate :","\"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using","self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined","---------- limit: int, optional Number of elements to display. Returns ------- tablesample An","'{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ]","Draws the box plot of the vColumn. Parameters ---------- by: str, optional vColumn","{} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL(","functionality for conducting # data science projects on data stored in Vertica, taking","self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed using a mean encoding with","useful for testing to be able to look at the final transformation. Returns","percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS","to the power of another number round : rounds a value to a","vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \" WHERE {}","= \"zscore\", by: list = [], return_trans: bool = False ): \"\"\" ---------------------------------------------------------------------------","utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return","== None: warning_message = \"The vColumn {} has no mode (only missing values).\\nNothing","count : Number of elements. density : Percentage of the distribution. mean :","--------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ---------- start: int","# # Special Methods # # ---# def __init__( self, alias: str, transformations:","vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \"\"\"","binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0,",": Number of elements. density : Percentage of the distribution. mean : Average","in transformations], ) self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\":","+ [str(count)]) ) query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER","for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=","as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also","\"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem","= \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def","vDataFrame.isin : Looks if some specific records are in the vDataFrame. \"\"\" if",") conditions, column = [], self.alias for idx in range(len(breaks) - 1): first_elem,","'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the","Returns the tail of the vColumn. Parameters ---------- limit: int, optional Number of","{} IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query,","first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r","The interval size to convert to use to convert the vColumn. If this","value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {},",": Applies a function to the vColumn. \"\"\" check_types( [ ( \"func\", func,","Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame","result = [self.min()] + result + [self.max()] elif method == \"topk\": assert k","\"auto\": method = \"mean\" if (self.isnum() and self.nunique(True) > 6) else \"mode\" total","was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied to the vColumn","user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The expression generated","is used for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers","assert len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks' must be greater or","See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\",","LIMIT {}\".format(limit) else: limit = \"\" query = \"(SELECT {} FROM {}{} OFFSET","dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ----------","Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing the","n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample","dropna: bool = False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth","True, the method will return the transformation used instead of the parent vDataFrame.","0 self.catalog[\"mad\"] = 1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0","of bins used for the discretization (must be > 1) k: int, optional","function to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if","the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)","nb = int(float(count / int(nbins))) assert nb != 0, Exception( \"Not enough values","aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the","- vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \"sturges\":","method=\"fetchall\", ) result = [elem[0] for elem in result] elif self.isnum() and method","are in the vColumn. You can write the following list: [\"Fouad\", \"Badr\"] Returns","\"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int, float]), ] )","self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to normalize.\", method=\"fetchall\", ) for i","(vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() ==","+ 1 or not (labels), ParameterError( \"Length of parameter breaks must be equal","Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the","or self.isdate(), ParameterError( \"numh is only available on type numeric|date\" ) if self.isnum():","None else \"NULL\", elem[1] if elem[1] != None else \"NULL\", ) for elem","ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT","force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT *","its affiliates. # Licensed under the Apache License, Version 2.0 (the \"License\"); #","{}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the descriptive statistics of","step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by =","or agreed to in writing, software # distributed under the License is distributed","{} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha","Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self):","brings the logic to the data. # # # Modules # # Standard","tangent cbrt : cube root ceil : value up to the next whole","---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b).","the vColumn. If this parameter is equal to 0, an optimised interval will","Integer corresponding to the offset. For example, if n = 1 then this","this issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations],","tmp_query + rp] query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format(","performance can drastically decrease. Returns ------- float quantile (or approximate quantile). See Also","information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn","] ), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{},","The vColumn '{}' was transformed with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"),","vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes","0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM","vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See Also --------","FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"]","skewness sum : sum std : standard deviation topk : kth most occurent","STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing","---# def head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head of","> {} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\"","around for processing, VerticaPy brings the logic to the data. # # #","input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest,","'{}' was normalized with the method '{}'.\".format( self.alias, method ) ) else: raise","number of non-missing elements cvar : conditional value at risk dtype : vColumn","{} IS NOT NULL \".format(self.alias) if (dropna) else \" \" result = executeSQL(","to 2 in case of discretization using the method 'topk'\" ) distinct =","'{label}'\" ] expr = \"CASE WHEN \" + \" WHEN \".join(conditions) + \"","= quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not be","is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self, add_history:","\".join(by) ), ) if return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg,","\"{}\" ) ) return self.parent # ---# def fillna( self, val=None, method: str","most occurent element percent : percent of non-missing elements q% : q quantile","'x' will represent the number of seconds, otherwise it will represent a number.",") .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3],","the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also","assert n >= 1, ParameterError(\"Parameter 'n' must be greater or equal to 1\")","the vColumn. method: dict, optional Method to use to impute the missing values.","title=\"Computing the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin =","vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies :","a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to impute","categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result for item","can be 'minute' 'hour'... start: bool, optional If set to True, the record","define the outliers. After normalizing the data (Z-Score), if the absolute value of","---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category is date,","Draws the donut chart of the vColumn based on an aggregation. \"\"\" if","+ prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") )","optional The method used for the plot. gaussian : Gaussian kernel. logistic :","than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers","result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\"","the License. # # |_ |~) _ _| _ /~\\ _ |. #","def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val","\"-./ \\ /\\ \"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____ \\","{} WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg","copy_trans = [elem for elem in self.transformations] total = self.count() if method not","transformed multiple times, so it's better practice to use this method when first","self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog","---------- x: float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply","] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, )","query = \"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM",") ) # ---# def spider( self, by: str = \"\", method: str","{}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{}","to False, the function's performance can drastically decrease. Returns ------- int vColumn cardinality","> max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations","verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---#","\"]\" else: op1, op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx","copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total > 0: try:","\"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was","seen as one column of that relation. vColumns simplify several processes with its","std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage","executeSQL( query=query, title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\", ) result","title=title) # ---# def numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the","def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha: float","== None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] -","|| ''\", \"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\", \"text\") if","offset < 0: offset = max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias)","histogram of the vColumn based on an aggregation. Parameters ---------- method: str, optional","except: model.drop() raise # ---# def describe( self, method: str = \"auto\", max_cardinality:","def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record","range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix,","float = 0, nbins: int = -1, k: int = 6, new_category: str","the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate","using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops","isinstance(order_by, str): order_by = [order_by] check_types( [ ( \"method\", method, [ \"auto\", \"mode\",","a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def","setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name]","verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL(","and self.nunique(True) > 6) else \"mode\" total = self.count() if (method == \"mode\")","dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn.","bool, optional If set to True, the approximate cardinality is returned. By setting","int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where =","pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]),","top{} categories of {}.\".format( k if k > 0 else \"\", self.alias ),","cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0: warning_message =","{} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else \"\" )","Returns True if the vColumn category is date. vDataFrame[].isnum : Returns True if","\"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\",","\\____ \\ \\ \\/\\ \\ \\ \\ \\____ \\ \\ \\_\\ \\ \\","record of the vColumn. vDataFrame[].extract : Extracts the regular expression in each record","{}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ),","is in each of the vColumn records. vDataFrame[].extract : Extracts the regular expression","the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\",","return self.parent except Exception as e: raise QueryError( \"{}\\nError when applying the func","tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])])","= True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx:","ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha,","column of that relation. vColumns simplify several processes with its abstractions. Parameters ----------","elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str =","tablesample(values) # ---# def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the","\"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool = False, ax=None, **style_kwds,","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"variance\"]).values[self.alias][0] variance","datetime.datetime, datetime.date] = \"\", area: bool = False, step: bool = False, ax=None,","executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except:","bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def","elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations)","SUM({}) AS events FROM ({}) x GROUP BY 1\".format( self.alias, y, y, query,","function to the vColumn. \"\"\" check_types( [ ( \"func\", func, [ \"abs\", \"acos\",","(\"offset\", offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] -","--------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object Any","'Others'. cat_priority: list, optional List of the different categories to consider when drawing","xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel,","discretize( self, method: str = \"auto\", h: float = 0, nbins: int =","quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not be empty\"","the vColumn by dropping the current vColumn and creating a copy with the","[list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by)","to compute the optimal h. auto : Combination of Freedman Diaconis and Sturges.","integer k of the 'topk' method. new_category: str, optional The name of the","copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def","each vColumn category. In this case, the parameter 'numcol' must be defined. numerical","columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was","for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self,","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---#","aggregation. aad : average absolute deviation approx_unique : approximative cardinality count : number","is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data","result[idx][0] = ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1]","the following: date / int / float / text / binary / spatial","ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH vdf_table AS","\"vColumn {} must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize(","if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is only available for","be able to look at the final transformation. Returns ------- vDataFrame self.parent See","return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function","all_partition = by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem","\"\"\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x: float","pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL(","two flower brackets {}. For example to apply the function: x -> x^2","Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns -------","\"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of digits","WHEN vColumn = argv[2 * i] THEN argv[2 * i + 1] ...","{}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query =","if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else:","str): order_by = [order_by] check_types( [ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\",","\"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1)","- {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ) else:","verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #","to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if","if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if","), ) else: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias,","if the vColumn is boolean, False otherwise. Returns ------- bool True if the","APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\".format(","self.alias), category, ) ) query += [lp + tmp_query + rp] query =","in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({},","be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum()","see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","\"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method","(val == None): val = self.mode(dropna=True) if val == None: warning_message = \"The","next whole number ln : natural logarithm log : logarithm log10 : base","(\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean","in query_result] index = [\"unique\", \"count\"] + [item[0] for item in query_result] else:","two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use","/ (1.4826 * mad) minmax : Normalization using the MinMax (min and max).","------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be numerical to use a","If set to True, draw a Step Plot. ax: Matplotlib axes object, optional","= skewness # ---# def slice(self, length: int, unit: str = \"second\", start:",".transpose() .values[self.alias] ) result = [distinct_count] + result index = [ \"unique\", \"count\",","\"\"\" columns = [self.alias] check = True if len(args) > 0: column =","self.alias, method ) ) else: raise TypeError(\"The vColumn must be numerical for Normalization\")","the most relevant interval to use for the discretization. topk : Keeps the","{}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0],","of non-Missing elements). Returns ------- int number of non-Missing elements. See Also --------","count = self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception(","**style_kwds Any optional parameter to pass to the Matplotlib functions. Returns ------- ax","Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None, None), ax=None,",">= 2, ParameterError( \"Length of parameter 'breaks' must be greater or equal to","vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict :","DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result =","in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix = (","One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a","total = int(total) conj = \"s were \" if total > 1 else","warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\") if val","names will be generated. include_lowest: bool, optional If set to True, the lowest","self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True,","\"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value","\"\", \"\" for category in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1})","was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val =","GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(),","Mode for the categorical vColumns. bfill : Back Propagation of the next element","- 1 ) result = executeSQL( query=query, title=\"Computing the optimized histogram nbins using","name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,","range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for","[list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(),","Number of bins. If empty, an optimized number of bins will be computed.","\"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur, and","bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0]","[item[1] for item in query_result] index = [\"unique\", \"count\"] + [item[0] for item","): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method:","or implied. # See the License for the specific language governing permissions and","in kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14,","n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT *","offset and a limit). Parameters ---------- limit: int, optional Number of elements to","(min and max). (x - min) / (max - min) by: list, optional","the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---# def","stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\"))","self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast =","will be computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional","\"NULL\", ) for elem in result if elem[1] != None ] ), )","f\"A vColumn has already the alias {name}.\\nBy changing the parameter 'name', you'll be","\"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna:","/ {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\", \"float\",","See Also -------- vDataFrame.bar : Draws the Bar Chart of the input vColumns","if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self,","elif h > 0.000001: h = round(h, 6) if self.category() == \"int\": h","Maximum number of vColumn distinct elements to be used as categorical. The less","to use to convert the vColumn. If this parameter is equal to 0,","Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time series. \"\"\"","/ int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where = \"WHERE","mean : Average of the vColumn 'of'. min : Minimum of the vColumn","If set to True, the intervals will be closed on the right. Returns","if self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema","if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(),",": Applies a function to all the vColumns. vDataFrame.eval : Evaluates a customized","elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent #","elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \"\"\"","(schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp","FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE","more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest","ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({})","query = \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER","- {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ), \"float\",","method 'robust_zscore' is available only if the parameter 'by' is empty\\nIf you want","a specific TS field from the vColumn. \"\"\" check_types( [ (\"length\", length, [int,","re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass","---# def discretize( self, method: str = \"auto\", h: float = 0, nbins:","rule. Parameters ---------- length: int Slice size. unit: str, optional Slice size unit.","with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of","SQL expression. by: list, optional vColumns used in the partition. order_by: list, optional","an advanced analytical function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg","APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =","categorical aggregations during the computation. cat_stats : Computes statistics of a numerical column","self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast,","slice): assert index.step in (1, None), ValueError( \"vColumn doesn't allow slicing having steps","verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem in copy_trans] for elem","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using","\".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\" ) func = \"(CASE","WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias),","FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query)","---------- start: int Start of the slicing. step: int Size of the slicing.","\"_\") ) ) name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\")","the parameter 'new_name', you'll be able to solve this issue.\" ) self.add_copy(new_name) parent","kth most occurent element (ex: top1 for the mode) topk_percent : kth most","cast the other types to varchar. same_freq : Computes bins with the same","_ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / #","picked or computed) h: float, optional Interval width of the bar. If empty,","str, optional The name of the merging category when using the 'topk' method.","self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception( \"Not enough","self.isnum() and method in (\"same_width\", \"auto\"): if not (h) or h <= 0:","Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \"\"\"","float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","the Information Value (IV) / Weight Of Evidence (WOE) Table. It tells the","the approximate cardinality is returned. By setting this parameter to False, the function's","= [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot of the","floor of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See","catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add","vDataFrame[].hist : Draws the histogram of the vColumn based on an aggregation. \"\"\"","xmin = self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines =","parameters used to compute the best splits when 'method' is set to 'smart'.","else \"NULL\", elem[2] if elem[2] != None else \"NULL\", ) for elem in","*args / **kwargs Any optional parameter to pass to the geopandas plot function.","in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\"","+ 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also --------","/ int(nbins))) assert nb != 0, Exception( \"Not enough values to compute the","if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types(","Returns True if the vColumn is numerical, False otherwise. Returns ------- bool True","type of pie chart. auto : Regular pie chart. donut : Donut chart.","the vColumn expected store usage (unit: b). Returns ------- int vColumn expected store","is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog","[] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else","return the mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent","if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category())","vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes","vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \"\"\" if isinstance(cat_priority,","] query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE","in sauv: if \"top\" in elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem]","input number of digits after the comma. Parameters ---------- n: int Number of","if by == []: if fun == \"AVG\": val = self.avg() elif fun","self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [ (","where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) )","Vertica, taking advantage Vertica’s # speed and built-in analytics and machine learning features.","unique... depending on the input method. Parameters ---------- method: str, optional The describe","check if Badr and Fouad are in the vColumn. You can write the","PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9)","): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional",") ] if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha == None:","Equal Frequency discretization\" ) total, query, nth_elems = nb, [], [] while total","See Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap :","= executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store","--------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns ------- float","self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn {} named {} was added","root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If","\\ /\\ \"-./ \\ /\\ \"-.\\ \\ # \\ \\ \\'/ \\ \\","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to","------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns","self.alias, ) query_result = executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\",","bound to the upper bound itself. Parameters ---------- lower: float, optional Lower bound.","aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0] = ( \"NULL\" if","Set the x limits of the current axes. ax: Matplotlib axes object, optional","), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ] ) method","self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS ord,","fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0),","datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool =","): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional","\"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int, float]), ]","will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops","(SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM","\"int\", \"bool\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem","Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.","self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn {} must be binary","greater or equal to 2.\" ) assert len(breaks) == len(labels) + 1 or","{} AS {}, {} AS ord, {}::int AS {} FROM {}\".format( trans, self.alias,","\"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])]) assert (lower != None)","int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors","\"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\",","the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify","float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) /","\"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\",","0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based","END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent #","self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", ) top = None","whole number ln : natural logarithm log : logarithm log10 : base 10","Version 2.0 (the \"License\"); # You may not use this file except in","name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn","self.distinct() if len(cat) == 1: lp, rp = \"(\", \")\" else: lp, rp","\"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias {new_name}.\\nBy changing","by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing the different","the vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters","BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to","-------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias,","Number of bins used for the discretization (must be > 1) k: int,","if the vColumn is numerical. \"\"\" return self.category() == \"date\" # ---# def","object See Also -------- vDataFrame.bar : Draws the Bar Chart of the input","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod","of the next element (Constant Interpolation). ffill : Propagation of the first element","self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts:","an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either","'numcol' must be defined. numerical : Uses popular numerical aggregations during the computation.","+= [lp + tmp_query + rp] query = \"WITH vdf_table AS (SELECT *","it is used to compute other vColumns. Parameters ---------- add_history: bool, optional If","NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title","(Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the","vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date","also increase the time of the learning and scoring phases. xlim: tuple, optional","a value to a specified number of decimal places sign : arithmetic sign","1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \"AVG({})","input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division by","int = -1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k most","---------- val: list List of the different records. For example, to check if","[str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\",","assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias of one of","(Z-Score), if the absolute value of the record is greater than the threshold,","occurent elements and their distributions as percents. Parameters ---------- k: int, optional Number","for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"]","= 6, h: float = 0, pie_type: str = \"auto\", ax=None, **style_kwds, ):","- {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev )","({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'.","if (nullifzero) else \"\", cmax, cmin, ) else: final_transformation = [ ( \"({}","then 'order_by' must be a list of at least one element to use","the Z-Score (avg and std). (x - avg) / std robust_zscore : Normalization","input functions. Parameters ---------- func: list List of the different aggregation. aad :","1) k: int, optional The integer k of the 'topk' method. new_category: str,","occurent elements. \"\"\" if \"agg\" not in kwargs: query = \"SELECT {} AS","\"[\" if idx == 0 and include_lowest: op1, close_l = \"<=\", \"[\" elif","set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame","1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION","vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes","\"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif",") query += [lp + tmp_query + rp] query = \"WITH vdf_table AS","threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05, ):","== 2, TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) response_cat","example: 0.25 represents Q1. approx: bool, optional If set to True, the approximate","an aggregation. vColumns will memorize the already computed aggregations to gain in performance.","{}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {},","self.alias return tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the","== \"smart\" ): n = len(result) trans = \"(CASE \" for i in","outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled.","ParameterError( \"Parameter 'response' can not be empty in case of discretization using the","return. dropna: bool, optional If set to True, NULL values will not be","the vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate :","creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of","optional Number of elements to display. Returns ------- tablesample An object containing the","nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset:","FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE {0} IS NOT NULL","return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---#","result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min,","performance can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate :","------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut","search. See Also -------- vDataFrame.isin : Looks if some specific records are in",") response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn {}","def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the","if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of","--------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur, and other","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def","optional If not empty, a copy will be created using the input Name.",": Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int,","\"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ]","the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result","float / text / binary / spatial / uuid / undefined Returns -------","logic to the data. # # # Modules # # Standard Python Modules","int, optional Maximum number of nbins used for the discretization (must be >","the other into one unique category. h: float, optional The interval size to","vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold'","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---#","\"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\".format( copy_name.replace('\"',","expression. \"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name,","str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned","quantile. For example: 0.25 represents Q1. approx: bool, optional If set to True,","self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception as e: raise","drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame.","\", \".join([quote_ident(column) + desc for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE","{} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for","of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int,","optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the first dummy","[elem for elem in transformations], ) self.catalog = { \"cov\": {}, \"pearson\": {},","0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS","\"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans: return","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def","For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn","(Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame","# ---# def slice(self, length: int, unit: str = \"second\", start: bool =","- pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER","= [val] val += list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val} return","self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN ({}) THEN {} || ''","k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = (","\"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int, optional","as categorical. The less frequent elements will be gathered together to create a","self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if","Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0]","self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100","amount of expressions. The expression generated will look like: even: CASE ... WHEN","not normalize {} using a Z-Score - The Standard Deviation is null !\".format(","= \" WHERE {} IS NOT NULL \".format(self.alias) if (dropna) else \" \"","---------- method: str, optional Method to use to fill the vColumn outliers. mean",": Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\",","self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import","return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self,","List of the different transformations. \"\"\" # # Special Methods # # ---#","{}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\",","[elem for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return","x: float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an","the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({},","missing elements in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str,","result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method","i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None","def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element to the vColumn.","discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name)","def apply(self, func: str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function","The vColumn {} was converted to {}.\".format( self.alias, dtype ) ) return self.parent","of the vColumn. Parameters ---------- limit: int, optional Number of elements to display.","{} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(),","{}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode","AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4}","(x - avg) / std robust_zscore : Normalization using the Robust Z-Score (median","_verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY {}","{new_name}.\\nBy changing the parameter 'new_name', you'll be able to solve this issue.\" )","{}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\".format( self.alias,","= '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx),","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws","= \"Can not normalize {} using a Z-Score - The Standard Deviation is","\"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self,","equal to 1\") where = \" WHERE {} IS NOT NULL \".format(self.alias) if","\"The method 'robust_zscore' is available only if the parameter 'by' is empty\\nIf you","bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper","sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, )","is boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn category","\"\"\" if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is only available","True if the vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") #","in compliance with the License. # You may obtain a copy of the","by an input value. The vColumn will be transformed. Parameters ---------- to_replace: str","Interval width of the bar. If empty, an optimized h will be computed.","License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or","def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent","to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) +","[ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ),","\"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\"","this parameter to False, the function's performance can drastically decrease. Returns ------- float","empty, a copy will be created using the input Name. Returns ------- vDataFrame","query ) query_result = executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\",","{})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\",","BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing","A float between 0 and 1 that represents the quantile. For example: 0.25","[int, float]), (\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =","float): \"\"\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x:","on numerical / date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length of","self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---#","{}.\".format( k if k > 0 else \"\", self.alias ), method=\"fetchall\", ) values","int, optional Integer corresponding to the offset. For example, if n = 1","True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs)","iv_woe(self, y: str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value","sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if \"top\" in elem: if","if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self,","= {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])]","use to determine if the vColumn will be considered as categorical. numcol: str,","= \"Can not normalize {} using the MIN and the MAX. MAX =","else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for k in","k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)]","Start Date. For example, time = '03-11-1993' will filter the data when 'ts'","the average of the response partitioned by the different vColumn categories. Parameters ----------","the number of seconds, otherwise it will represent a number. Returns ------- vDataFrame","(use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \",","and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError(","warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try:","n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax","of matches for the regular expression in each record of the vColumn. vDataFrame[].extract","--------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str, Function in","\"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method = method.lower()","or one of its affiliates. # Licensed under the Apache License, Version 2.0","element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\",","self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv:","upper, [float, int])]) assert (lower != None) or (upper != None), ParameterError( \"At","1) or (self.category() == \"float\"): trans = ( \"'[' || FLOOR({} / {})","\"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill then 'order_by'","The name of the merging category when using the 'topk' method. RFmodel_params: dict,","by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k","\"(\", \")\" else: lp, rp = \"\", \"\" for category in cat: tmp_query","self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \"SELECT {} FROM (SELECT {}","\", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), )","[(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label",": Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response","= ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr","categories {} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format(","an input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])]) return","str, optional The method used for the plot. gaussian : Gaussian kernel. logistic","self.alias ), method=\"fetchall\", ) values = { \"index\": [item[0] for item in result],","the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :",") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7],","# |_ |~) _ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_|||","result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result =","Label Encoding was applied to the vColumn {} using the following mapping:{}\".format( self.alias,","\"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str):","return self elif n == 1: try: result = executeSQL( \"SELECT {}, MIN({}),","'same_width' for numerical vColumns, cast the other types to varchar. same_freq : Computes","threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05 ):","== \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN","Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for k","] ) assert self.isnum() or self.isdate(), TypeError( \"cut only works on numerical /","else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False,","'labels' + 1 or parameter 'labels' must be empty.\" ) conditions, column =","= True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers","will be included. right: bool, optional How the intervals should be closed. If","distributions as percents. Parameters ---------- k: int, optional Number of most occurent elements","optional If set to True, the approximate median is returned. By setting this","(1.4826 * mad) minmax : Normalization using the MinMax (min and max). (x","columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\"color\": colors[idx %","{}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[2] if elem[2] !=","skip. Returns ------- tablesample An object containing the result. For more information, see","to use to impute the vColumn. method: dict, optional Method to use to","---# def iv_woe(self, y: str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the",") ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema =","RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used to compute","set to True, the information will be stored in the vDataFrame history. Returns","str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ----------","\"robust_zscore\": if n > 0: warning_message = \"The method 'robust_zscore' is available only","The vColumn type must be date like (date, datetime, timestamp...) or numerical. q:","{} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1)","\"({} - {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else","nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in","= self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} < {}\".format( self.alias, result[\"avg\"][0],","self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---#","= len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations += [(\"{}\",","function to the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels,","def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean).","check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold,","new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean =","Warning) return self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\") if val !=","the vColumn using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate","category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try:","from the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\", unit, [str]),","Parameters ---------- k: int, optional Number of most occurent elements to return. Returns","\"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\",","(IV) / Weight Of Evidence (WOE) Table. It tells the predictive power of","import * from verticapy.toolbox import * from verticapy.errors import * ## # #","New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the","\"value\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method == \"categorical\"))","of discretization using the method 'same_freq'\" ) count = self.count() nb = int(float(count","gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins'","vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent","distinct_count > max_cardinality: query += ( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT","self.parent.filter( \"ABS({} - {}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold )","Also -------- vDataFrame.filter: Filters the data using the input expression. \"\"\" self.parent.filter(\"{} IS","processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional","using previously the method on the vColumn \" \"or simply because of ambiguous","number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function","Also -------- vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws","RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else:","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global","2) + 2\". copy_name: str, optional If not empty, a copy will be","(\"float\", \"int\"), TypeError( \"The column 'numcol' must be numerical\" ) cast = \"::int\"","> max_cardinality: query += ( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*)","for sublist in query_result for item in sublist] # ---# def div(self, x:","\"index\": [item[0] for item in result], \"count\": [int(item[1]) for item in result], \"percent\":","self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING","bool = True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns","Parameters ---------- argv: object Any amount of expressions. The expression generated will look","Returns True if the vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\")","ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---# def describe(","---# def numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn","of a response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode","), ) if return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\"","do not apply it. This parameter is very useful for testing to be","-------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int,","\"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB type.","optional The method to use to discretize the vColumn. auto : Uses method","(dropna): n = \"\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal):","------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers.","The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if some","y: str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV)","= product # ---# def quantile(self, x: float, approx: bool = True): \"\"\"",": Maximum of the vColumn 'of'. sum : Sum of the vColumn 'of'.","the next element (Constant Interpolation). ffill : Propagation of the first element (Constant","a user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The expression","area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by:","self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut,","numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality +","(FLOOR({} / {}) * {} + {}{}) || ']'\".format( \"{}\", h, h, \"{}\",","vColumn will be considered as categorical. numcol: str, optional Numerical vColumn to use","[str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace:","partition the data. bandwidth: float, optional The bandwidth of the kernel. kernel: str,","= 30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they","approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'.","n: int, optional Offset. Returns ------- tablesample An object containing the result. For","vColumn. transformations, str : List of the different transformations. \"\"\" # # Special","expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self, dtype:","a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x","self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype),","dict, optional Dictionary of the Random Forest model parameters used to compute the","of the vColumn distinct elements to be used as categorical (No h will","lower outliers by their respective average. null : Replaces the outliers by the","result = executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP","{} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return","func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT {} AS","the same number of elements. same_width : Computes regular width bins. smart :",") for elem in result if elem[1] != None ] ), ) cmax","new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and","\"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result, } if ((is_date)","str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression in","vColumn using a bijection from the different categories to [0, n - 1]","if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column =","!= None): return pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must be greater","list will be included. right: bool, optional How the intervals should be closed.","the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias:","else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1] == None) else str(elem[1])","loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on","= 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n:","Verifies if the regular expression is in each of the vColumn records. vDataFrame[].extract","\\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/","{}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, )",") ) # ---# def str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices","(is_date) and not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index =","vColumn = argv[2 * i] THEN argv[2 * i + 1] ... END","[int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by:","x, [int, float])]) assert x != 0, ValueError(\"Division by 0 is forbidden !\")","(sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif method == \"zscore\":","\"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\",","*args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn and","1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool,","to be able to look at the final transformation. Returns ------- vDataFrame self.parent","vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func:","IS NOT NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT {} AS {},",": Returns the tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\",","in case of discretization using the method 'same_freq'\" ) count = self.count() nb","to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical : Uses","deleted from the vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold:","kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in kwargs): from verticapy.plot import gen_colors","*= 1.4826 if mad != 0: if return_trans: return \"({} - {}) /","= self.max() else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct()","int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often","(\"numcol\", numcol, [str]), ] ) method = method.lower() assert (method != \"cat_stats\") or","self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM","# ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute","'ts' is lesser than November 1993 the 3rd. end_date: str / date, optional","1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \"MAX({})","ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset: int =","\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1],","lower, [float, int]), (\"upper\", upper, [float, int])]) assert (lower != None) or (upper","Also -------- vDataFrame.plot : Draws the time series. \"\"\" check_types( [ (\"ts\", ts,","---# def normalize( self, method: str = \"zscore\", by: list = [], return_trans:","optional If set to True, the lowest element of the list will be","store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage.","OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format(","\"same_freq\") or ( self.isnum() and method == \"smart\" ): n = len(result) trans","check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs):","and their distributions as percents. Parameters ---------- k: int, optional Number of most","column = kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column)","an optimized h will be computed. ax: Matplotlib axes object, optional The axes","if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM","DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(),","_verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the","int(float(count / int(nbins))) assert nb != 0, Exception( \"Not enough values to compute","self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\":","(\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn","create a new category : 'Others'. cat_priority: list, optional List of the different","{}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} largest elements.\".format(self.alias,","] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format( self.alias, dtype )","[], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx","{} was renamed '{}'.\".format(old_name, new_name) ) return parent # ---# def round(self, n:","(\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float,","== 1: try: result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP","OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format(","computed aggregations to gain in performance. The catalog will be updated when the","use a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for","One vDataFrame can have multiple children vColumns whereas one vColumn can only have","based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of, [str]),","upper bound quantile(1-alpha) if 'use_threshold' is set to False else the lower and","{}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_","avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can not","* sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was","result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY","verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias,","of the vColumn. transformations, str : List of the different transformations. \"\"\" #","'{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self, func:",") warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50):","= self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name,","= 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold:","the topk most frequent categories and merge the other into one unique category.","and creating a copy with the specified name. \\u26A0 Warning : SQL code",": Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply(","NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(),","the vColumn records. The vColumn will be transformed. Parameters ---------- pat: str Regular","/ # \\ / # \\/ # _ # \\ / _ __|_.","self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {},","not (labels), ParameterError( \"Length of parameter breaks must be equal to the length","category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the","raise QueryError( \"{}\\nError when applying the func 'x -> {}' to '{}'\".format( e,","(No h will be picked or computed) h: float, optional Interval width of","(\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int,","encoding of a response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message = (","not selecting it in the final generated SQL code. Note: Dropping a vColumn","numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must","use to normalize. zscore : Normalization using the Z-Score (avg and std). (x","query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION","different categories to [0, n - 1] (n being the vColumn cardinality). Returns","= 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol,","---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores all user transformations.","avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix","parameter is very useful for testing to be able to look at the","vColumn can make the vDataFrame \"heavier\" if it is used to compute other","value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements,","type is date like). The vColumn will be transformed. Parameters ---------- field: str","of elements. same_width : Computes regular width bins. smart : Uses the Random","category, ) ) query += [lp + tmp_query + rp] query = \"WITH","to transform the vColumn. abs : absolute value acos : trigonometric inverse cosine","= executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method ==","k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)]","vColumn to the input type. Parameters ---------- dtype: str New type. Returns -------","[int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must","quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]),","{} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {}",") func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent #","\"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not be empty\" )","vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True if the","RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name,","), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__()","bool, optimal If set to True, the method will return the transformation used","vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if some specific","\"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","binary / spatial / uuid / undefined Returns ------- str vColumn category. See","def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str","new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\",","- alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha,","[CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \"\"\" check_types( [(\"method\", method,","one of its affiliates. # Licensed under the Apache License, Version 2.0 (the","AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE",": Returns the a part of the vColumn. \"\"\" return self.iloc(limit=limit) # ---#","float]), ] ) if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr =","vColumn {} can not be converted to {}\".format( e, self.alias, dtype ) )","self.alias, \", \".join(by) ), ) else: avg, stddev = ( \"AVG({}) OVER (PARTITION","- {}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\",","check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self,","Dropping a vColumn can make the vDataFrame \"heavier\" if it is used to","return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list = [],","If set to True, draw an Area Plot. step: bool, optional If set","optional Slice size unit. For example, it can be 'minute' 'hour'... start: bool,","dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements and","{} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha =","NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias),","{}, response: str = \"\", return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes","distinct elements to be used as categorical. The less frequent elements will be","= 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method.","be computed. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","{}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {},","vColumn (only if the vColumn type is date like). The vColumn will be","sublist in query_result for item in sublist] # ---# def div(self, x: float):","---# def iloc(self, limit: int = 5, offset: int = 0): \"\"\" ---------------------------------------------------------------------------","vColumn {} using the following mapping:{}\".format( self.alias, text_info ) ) return self.parent #","__ `\\ / / # | \\/ / / / # |______ /","= \"density\", of: str = \"\", max_cardinality: int = 6, h: float =","n == 0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev","must be date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn","least 'lower' or 'upper' must have a numerical value\" ) lower_when = (","\"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, )","\"float\", \"float\", ) ] elif method == \"robust_zscore\": if n > 0: warning_message","Date. For example, time = '03-11-1993' will filter the data when 'ts' is","assert self.isnum() or self.isdate(), TypeError( \"cut only works on numerical / date-like vColumns.\"","str, optional SQL expression. by: list, optional vColumns used in the partition. order_by:","[int, float]), (\"numcol\", numcol, [str]), ] ) method = method.lower() assert (method !=","< 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop","Plot. Parameters ---------- by: str, optional vColumn to use to partition the data.","categorical (No h will be picked or computed) h: float, optional Interval width","Returns a part of the vColumn (delimited by an offset and a limit).","), title=\"Computing the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin",") self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier,","== \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or","True if pie_type == \"donut\" else False rose = True if pie_type ==","different than 1.\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start,","1.0, kernel: str = \"gaussian\", nbins: int = 200, xlim: tuple = None,","input method. Parameters ---------- method: str, optional Method to use to fill the","(\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float,","of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str :","and lower outliers by their respective average. null : Replaces the outliers by","method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result","else \"\", cmax, cmin, ) else: final_transformation = [ ( \"({} - {})","as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, )","new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of","of the vColumn 'of' (ex: 50% to get the median). It can also","Parameters ---------- method: str, optional Method to use to normalize. zscore : Normalization","(Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame","'{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent,","trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS","] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return","average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","return self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input","alias, str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent,","'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value","for idx, elem in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] == None)","to the vColumn {} using the following mapping:{}\".format( self.alias, text_info ) ) return","ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total =","column in by]) ) if (by) else \"\" ) order_by_ts = \", \".join([quote_ident(column)","if the vColumn category is date, False otherwise. Returns ------- bool True if","data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent #","Prefix delimitor of the dummies. drop_first: bool, optional Drops the first dummy to","step: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series","True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ----------","bar width. Parameters ---------- method: str, optional Method to use to compute the","a bijection from the different categories to [0, n - 1] (n being","regular expression is in each of the vColumn records. The vColumn will be","the vColumn using multiple statistical aggregations: min, max, median, unique... depending on the","# \\ / / / # \\/ / / # / / #","for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid :","= ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in by]) ) if","vColumn = argv[2 * i] THEN argv[2 * i + 1] ... ELSE","and 2 to be used as categorical (No h will be picked or","normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join(","For example: 0.25 represents Q1. approx: bool, optional If set to True, the","/ text / binary / spatial / uuid / undefined Returns ------- str","records are in the vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)):","vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of","the Apache License, Version 2.0 (the \"License\"); # You may not use this","mode : most occurent element percent : percent of non-missing elements q% :","= True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions",": standard deviation topk : kth most occurent element (ex: top1 for the","vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn can only","int, optional Offset. Returns ------- tablesample An object containing the result. For more","method: str, optional The method to use to aggregate the data. count :","return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only available on type","catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1,","abs(self.count() - total) except Exception as e: self.transformations = [elem for elem in","'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame","distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and","to the vColumn. \"\"\" check_types( [ ( \"func\", func, [ \"abs\", \"acos\", \"asin\",","length, [int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ] ) start_or_end =","______ ______ __ __ __ __ __ __ __ # /\\ \\ /",": Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn","one of the following: CENTURY / DAY / DECADE / DOQ / DOW","{}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\"Different","-------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns","} if ((is_date) and not (method == \"categorical\")) or ( method == \"is_numeric\"","the vColumn 'of'. min : Minimum of the vColumn 'of'. max : Maximum",": Slices the vColumn using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field,","(Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame","computed) ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","elem[1] if elem[1] != None else \"NULL\", ) for elem in result if","for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations +=","Error happened during the filling.\".format(e)) if total > 0: try: if \"count\" in","data. bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional The","applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) )","int, optional Cardinality threshold to use to determine if the vColumn will be","ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates","# ---# def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific","\".format( \"{}\", result[i - 1], result[i], result[i - 1], result[i] ) trans +=","aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use to determine","{}, format = 'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ] query","the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical.",": Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def","self.alias, n ) title = \"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query,","vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response)","by their respective average. null : Replaces the outliers by the NULL value.","({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","the intervals should be closed. If set to True, the intervals will be","the Plot. start_date: str / date, optional Input Start Date. For example, time","= \"_\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \"\"\" ---------------------------------------------------------------------------","slicing having steps different than 1.\" ) index_stop = index.stop index_start = index.start","method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can not be empty in","in query_result for item in sublist] # ---# def div(self, x: float): \"\"\"","during the filling.\".format(e)) if total > 0: try: if \"count\" in sauv: self.catalog[\"count\"]","if return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero)","stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop:","/\\ ___\\ /\\ __ \\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\","be computed. h: float, optional Interval width of the bar. If empty, an","Box Plot of the input vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority,","datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool = False,","product range : difference between the max and the min sem : standard","the data. h: float, optional Interval width if the vColumn is numerical or","a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"',","no mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent","'\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not","2.\" ) assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \"Length","Aggregates the vColumn using 'sem' (standard error of mean). Returns ------- float sem","are in the vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val","ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\".format( self.alias,","datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts =","\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts","must be similar to the following: (function, type, category) parent: vDataFrame, optional Parent","\"\", bandwidth: float = 1.0, kernel: str = \"gaussian\", nbins: int = 200,","were \" if total > 1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{}","as categorical (No h will be picked or computed) h: float, optional Interval","result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0],","if some specific records are in the vColumn and it returns the new","self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif method","ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart","/ / # \\ / / / # \\/ / / # /","Number of elements to skip. Returns ------- tablesample An object containing the result.","type must be date like (date, datetime, timestamp...) or numerical. by: str, optional","(\"by\", by, [list]), (\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for","Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"x\",","\"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns = [ column for","fun, \"{}\", \", \".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert","(nullifzero) else \"\", stddev ) else: final_transformation = [ ( \"({} - {})","date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to use","), (\"x\", x, [int, float]), ] ) if func not in (\"log\", \"mod\",","Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","different categories to normalize.\", method=\"fetchall\", ) for i in range(len(result)): if result[i][2] ==","If the vDataFrame represents the entire relation, a vColumn can be seen as","of vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\",","aggregations: min, max, median, unique... depending on the input method. Parameters ---------- method:","--------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad","), ) if return_trans: return \"({} - {}) / {}({} - {})\".format( self.alias,","int))) else \"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func)","i] THEN argv[2 * i + 1] ... END odd : CASE ...","records. vDataFrame[].extract : Extracts the regular expression in each record of the vColumn.","(nullifzero) else \"\", stddev ), \"float\", \"float\", ) ] elif method == \"robust_zscore\":","input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels:","< 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <=","Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode","/ 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar","self.alias, name ) ) return self.parent # ---# def aggregate(self, func: list): \"\"\"","x)) # ---# def drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the","\"SELECT {}, {}({}) FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0]","kurtosis jb : Jarque-Bera index mad : median absolute deviation max : maximum","[int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]), ] ) if","return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot(","vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) )","self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM","(\"unit\", unit, [str]), (\"start\", start, [bool]), ] ) start_or_end = \"START\" if (start)","expr = [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)): expr += [","\"\", cmax, cmin, ), \"float\", \"float\", ) ] if method != \"robust_zscore\": max_floor","float = 4.0, use_threshold: bool = True, alpha: float = 0.05 ): \"\"\"","you want to normalize by grouping by elements, please use a method in","10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ----------","str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in","See Also -------- vDataFrame[].apply : Applies a function to the vColumn. \"\"\" check_types(","\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\".format(","non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS","\"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum()","def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns","= gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter","if the absolute value of the record is greater than the threshold it","elements to be used as categorical (No h will be picked or computed)","\"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\",","rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn","Labels used to name the new categories. If empty, names will be generated.","the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}',","(\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \"cut only works","elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] -","FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: avg, stddev = (","start, [bool]), ] ) start_or_end = \"START\" if (start) else \"END\" return self.apply(","decrease. Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate :","of the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also","using the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply :","---# def median( self, approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the","astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters","solve this issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in","\"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses","avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\"))","self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace: str, value:","\"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def",") # ---# def str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the","otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats : Computes","optional SQL expression. by: list, optional vColumns used in the partition. order_by: list,","the vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func","expr) elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif method","field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only","== \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] )","return self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn","\"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\":","check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right,","is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\"","value: str, optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains","drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also --------","sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the","return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name:","method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn","self.isnum(): if method == \"zscore\": if n == 0: nullifzero = 0 avg,","--------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func: str Function","of nbins will be computed. h: float, optional Interval width of the bar.","self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return","LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols,","* sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) /","relation to the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int,","Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate","will be computed. ax: Matplotlib axes object, optional The axes to plot on.","max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations","date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean.","(\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\")","return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr,","the method to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical","[(new_column, ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem] =","not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result","if the parameter 'by' is empty\\nIf you want to normalize by grouping by","chart. auto : Regular pie chart. donut : Donut chart. rose : Rose","percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias),",": Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True if","title=\"Computing the mode.\", method=\"fetchall\", ) top = None if not (result) else result[0][0]","0 self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] =","self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count,","result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 -","= 4.0, use_threshold: bool = True, alpha: float = 0.05, ): \"\"\" ---------------------------------------------------------------------------","\"AVG\": val = self.avg() elif fun == \"MEDIAN\": val = self.median() new_column =","max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool = True): \"\"\"","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See Also","categorical vColumns. bfill : Back Propagation of the next element (Constant Interpolation). ffill","\"::float\" if self.category() == \"float\" else \"\" if index < 0: index +=","return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool = True):","0: warning_message = \"The method 'robust_zscore' is available only if the parameter 'by'","expression matches in each of the vColumn record by an input value. The","\"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{} AS {} FROM {}","or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in","using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN","the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix","= {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem","of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1] for item in","(n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\":","executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\":","if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor","# / # ____________ ______ # / __ `\\ / / # |","[str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]), ] ) if by:","\"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self, start: int,","self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations","'method' is set to 'smart'. A RF Regressor will be trained if the","regular expression matches in each of the vColumn records by an input value.","order the data. The vColumn type must be date like (date, datetime, timestamp...)","self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding.","h > 0.01: h = round(h, 2) elif h > 0.0001: h =","the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x))","vColumns using the input method. Parameters ---------- method: str, optional Method to use","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis","approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","title=\"Computing the average of the {}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\",","is part of the DB version you are using. Returns ------- tablesample An","cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0: warning_message = \"Can","\"int\") else \"\" if (h > 1) or (self.category() == \"float\"): trans =","---# def slice(self, length: int, unit: str = \"second\", start: bool = True):","Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in each of","self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality,","val=None, method: str = \"auto\", expr: str = \"\", by: list = [],","1, len(by) if self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning)","= \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct() if len(cat)","**style_kwds) # ---# def iloc(self, limit: int = 5, offset: int = 0):","of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the","] if method != \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] + index,","0 for column in all_cols: try: if (quote_ident(column) in func) or ( re.search(","{}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0],","the vColumn. Parameters ---------- by: str, optional vColumn to use to partition the","LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title,","See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by,","elements, how often they occur, and other statistical information. Parameters ---------- k: int,","to True, the approximate cardinality is returned. By setting this parameter to False,","add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping",": Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int,","IN ({}) THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [","the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements to","import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#","Slice size. unit: str, optional Slice size unit. For example, it can be","division operation pow : number raised to the power of another number round","return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int = 5):","return self.parent # ---# def nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns","axes object \"\"\" columns = [self.alias] check = True if len(args) > 0:","\"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the","= [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\",","(\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ] )","result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha],","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] #",") else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias]","self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat:","2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins","[ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ]","exp : exponential function floor : value down to the next whole number","range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE","self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str = \"auto\"): \"\"\"","\".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if","0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS","drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the","encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor):","modified. Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog of","1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr, \"bool\", \"int\")]","vDataFrame[].bar : Draws the Bar Chart of vColumn based on an aggregation. \"\"\"","the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) )","--------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns ------- bool","the Box Plot of the input vColumns. \"\"\" if isinstance(cat_priority, str) or not","AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias),","def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will","limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters","see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn.","to order the data. The vColumn type must be date like (date, datetime,","usage (unit: b). Returns ------- int vColumn expected store usage. See Also --------","+ 5). ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","the optimized histogram nbins using Random Forest.\", method=\"fetchall\", ) result = [elem[0] for","self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", )","1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias,","series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str,","method=\"model\") result = [self.min()] + result + [self.max()] elif method == \"topk\": assert","vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {} WHERE","using 'mad' (median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate","object See Also -------- vDataFrame.donut : Draws the donut chart of the vColumn","numerical. by: str, optional vColumn to use to partition the TS. start_date: str","cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\",","# \\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\ \\ \\","---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only","-> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---#","+= [ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr","pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self,","of {}.\".format( k if k > 0 else \"\", self.alias ), method=\"fetchall\", )","elements q% : q quantile (ex: 50% for the median) prod : product","# # Unless required by applicable law or agreed to in writing, software","float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","True if the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn","1.\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start","compute the optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis","of another number round : rounds a value to a specified number of","auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2","threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns","either express or implied. # See the License for the specific language governing","the new categories. If empty, names will be generated. include_lowest: bool, optional If","kwargs: query = \"SELECT {} AS {} FROM {} WHERE {} IS NOT","the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes","processing, VerticaPy brings the logic to the data. # # # Modules #","self.isnum() and method == \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins' must","{} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({})","float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, )","\"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return parent # ---#","right: op1, op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else: op1, op2,",") ) # ---# def apply_fun(self, func: str, x: float = 2): \"\"\"","{}\".format( \", \".join([quote_ident(column) for column in by]) ) if (by) else \"\" )","+= [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn {} named {}","= RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params)","in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value","= (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str","self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized","int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed.","outliers. mean : Replaces the upper and lower outliers by their respective average.","IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str =","--------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also --------","\".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else \"\" ) upper_when = (","): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in transformations],","optional Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns","self.alias, \", \".join(by) ), ) if return_trans: return \"({} - {}) / {}({}","5). of: str, optional The vColumn to use to compute the aggregation. max_cardinality:","# ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns","\"[Get Dummies]: One hot encoder was applied to the vColumn {}\\n{} feature{}created: {}\".format(","instead of the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold.","] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by","NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype =",") ] if method != \"robust_zscore\": max_floor = 0 for elem in by:","method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0]","else: limit = \"\" query = \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format(","len(labels) + 1 or not (labels), ParameterError( \"Length of parameter breaks must be","the License. # You may obtain a copy of the License at #","/ 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif","if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \"method\", method, [ \"auto\",",": Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\",","None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"])","= max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool = True):","(ex: AVG(column1) + 5). of: str, optional The vColumn to use to compute","(lower != None) or (upper != None), ParameterError( \"At least 'lower' or 'upper'","h > 0.000001: h = round(h, 6) if self.category() == \"int\": h =","bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method.","Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool","{}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self,","= self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors()","method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha ==","= self.alias return tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if","--------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used are the","def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum",") ) else: for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations","argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a","name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax,","Method to use to normalize. zscore : Normalization using the Z-Score (avg and","the regular expression matches in each of the vColumn record by an input","\"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM","see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements.","WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias,","Any optional parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self,","\"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1,","(self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias {name}.\\nBy changing the parameter 'name',","int Number of digits to keep after the comma. Returns ------- vDataFrame self.parent","= None if not (result) else result[0][0] if not (dropna): n = \"\"","i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---#","dtype: str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype :","-------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types( [","AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, )","str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ (","bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing the","0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"',","\"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed using","the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def",") assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias of one","some specific records are in the vDataFrame. \"\"\" if isinstance(val, str) or not","6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","key corresponds to an aggregation. vColumns will memorize the already computed aggregations to","label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column}","\\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\ \\ \\ \\____","( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\") +",": Returns True if the vColumn category is date. \"\"\" return self.category() in","Other aggregations could work if it is part of the DB version you","( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ]","Robust Z-Score - The MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return","threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({}",") method = method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if","( 1.4826 * sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] = (sauv[elem] -","\"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\": values","elements to return. Returns ------- tablesample An object containing the result. For more","if method != \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] + index, \"value\":","query = \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start,","\"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\") and (numcol","(delimited by an offset and a limit). Parameters ---------- limit: int, optional Number","n smallest elements in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query =","(self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {}","try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = (","seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent See Also","{} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\" ) func =","by, [list]), (\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem","of the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :","__|_. _ _ |_) # \\/ (/_| | |(_(_|| \\/ # / #","LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias]","OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1) query =","new vColumn labeled with 0 and 1 (1 meaning global outlier). \"\"\" if","be considered during the computation. n: int, optional Integer corresponding to the offset.","by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority,",": vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame :","LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts )","--------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on an aggregation.","each of the vColumn record by an input value. The vColumn will be","will be picked or computed) ax: Matplotlib axes object, optional The axes to","-------- vDataFrame[].tail : Returns the a part of the vColumn. \"\"\" return self.iloc(limit=limit)","else: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result","(\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill","\"\"), EmptyParameter( \"The parameter 'name' must not be empty\" ) assert not (self.parent.is_colname_in(name)),","ax=ax, **style_kwds, ) # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","See Also -------- vDataFrame[].isdate : Returns True if the vColumn category is date.","WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha,","---------- dropna: bool, optional If set to True, NULL values will not be","\\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\","upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the","int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop,","index, self.alias: result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i],","float between 0 and 1 that represents the quantile. For example: 0.25 represents","labeled with 0 and 1 (1 meaning global outlier). \"\"\" check_types( [ (\"alpha\",","!\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if n","--------------------------------------------------------------------------- Computes the number of matches for the regular expression in each record","return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns","distribution. mean : Average of the vColumn 'of'. min : Minimum of the","BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query =","at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed","(max - min) by: list, optional vColumns used in the partition. return_trans: bool,","vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---#",") ) return self.parent except Exception as e: raise ConversionError( \"{}\\nThe vColumn {}","quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\",","func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self, func: str, x:","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut","k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info +=","isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top","in result if elem[2] != None ] ), ) executeSQL( \"SELECT {}, {}",": Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \"\"\" check_types(","\"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x: float","(\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def","* COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER BY","- cmin == 0: warning_message = \"Can not normalize {} using the MIN","return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input","({name}).\\n\" \"It can be the result of using previously the method on the","\" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied to the","\"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if","defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with","One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes","elements). Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate :","spider( self, by: str = \"\", method: str = \"density\", of: str =","include_lowest: bool, optional If set to True, the lowest element of the list","---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the","max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum","(use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A","of non-missing elements q% : q quantile (ex: 50% for the median) prod","each record of the vColumn. vDataFrame[].extract : Extracts the regular expression in each","optimized h will be computed. pie_type: str, optional The type of pie chart.","vColumn '{}' was normalized with the method '{}'.\".format( self.alias, method ) ) else:","= vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name,","(self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct() if len(cat) == 1: lp,","\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events","'03-11-1993' will filter the data when 'ts' is lesser than November 1993 the","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev =","chart. It can also be a cutomized aggregation (ex: AVG(column1) + 5). ax:","algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional","\".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[1]","vColumn type must be date like (date, datetime, timestamp...) or numerical. by: str,","the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges","bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list.","x: int/float, optional If the function has two arguments (example, power or mod),","__init__( self, alias: str, transformations: list = [], parent=None, catalog: dict = {}","ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str,","= 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0:","n >= 1, ParameterError(\"Parameter 'n' must be greater or equal to 1\") where","scoring phases. xlim: tuple, optional Set the x limits of the current axes.","[self.alias, self.ctype()] + result, } if ((is_date) and not (method == \"categorical\")) or","breaks must be equal to the length of parameter 'labels' + 1 or","self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds)","Parameters ---------- by: str, optional vColumn to use to partition the data. h:","the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional","= ( \"WHEN {} > {} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper,","optional Number of nbins. If empty, an optimized number of nbins will be","rp] query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \"","[], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified","intervals should be closed. If set to True, the intervals will be closed","transforms the vColumn using a time series rule. Parameters ---------- length: int Slice","20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations",") ) name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\",","+= [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] +=",") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts,","False otherwise. Returns ------- bool True if the vColumn category is date. See",") mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\"Computing the","float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int =",") executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ),","float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar","will be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent","Regressor will be trained if the response is numerical (except ints and bools),","vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\",","may not use this file except in compliance with the License. # You","self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn","to 0, an optimised interval will be computed. nbins: int, optional Number of","parent vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame self.parent","0 limit = \" LIMIT {}\".format(limit) else: limit = \"\" query = \"(SELECT","range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias])","- The Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self","lower) if (isinstance(lower, (float, int))) else \"\" ) upper_when = ( \"WHEN {}","y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS ord, SUM(1 -","Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","object Any amount of expressions. The expression generated will look like: even: CASE","if isinstance(by, str): by = [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]),","in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name]","# / / # \\ / # \\ / # \\/ # _","be seen as one column of that relation. vColumns simplify several processes with","x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, )","flower brackets {}. For example to apply the function: x -> x^2 +","has two arguments (example, power or mod), 'x' represents the second argument. Returns","filling.\".format(e)) if total > 0: try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"])","lower_when = ( \"WHEN {} < {} THEN {} \".format(\"{}\", lower, lower) if","vColumn records. The vColumn will be transformed. Parameters ---------- pat: str Regular expression.","Methods # # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad'","result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the","check_types( [ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ]","is numerical (except ints and bools), a RF Classifier otherwise. Example: Write {\"n_estimators\":","100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT","if method != \"robust_zscore\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations)","Gaussian distribution to define the outliers. After normalizing the data (Z-Score), if the","outliers using the input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float,","name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or equals",") ] elif method == \"robust_zscore\": if n > 0: warning_message = \"The","as categorical (No h will be picked or computed) nbins: int, optional Number","display. Returns ------- tablesample An object containing the result. For more information, see","for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=","best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h","Random Forest.\", method=\"fetchall\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name,","def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns","bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method =","vColumn. vDataFrame[].extract : Extracts the regular expression in each record of the vColumn.","2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"]","the vColumn. Parameters ---------- func: str Function to use to transform the vColumn.","\"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: avg, stddev","\\ \\ \\____ \\ \\ \\/\\ \\ \\ \\ \\____ \\ \\ \\_\\","50% to get the median). It can also be a cutomized aggregation (ex:","= to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"]","= \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by,","VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC","self, approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'.","\"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else:","expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column = \"DECODE({},","/ __ `\\ / / # | \\/ / / / # |______","func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except","and as upper bound quantile(1-alpha) if 'use_threshold' is set to False else the","a time series rule. Parameters ---------- length: int Slice size. unit: str, optional","# VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import *","Aggregates the vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate",") # ---# def str_replace(self, to_replace: str, value: str = \"\"): \"\"\" ---------------------------------------------------------------------------","_verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER","is greater than the threshold it will be considered as an outlier. use_threshold:","axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot of the","---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha:","method will return the mode of the vColumn. Returns ------- str/float/int vColumn nth","1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and","the vColumn. transformations, str : List of the different transformations. \"\"\" # #","issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog,","list List of the different aggregation. aad : average absolute deviation approx_unique :","'{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self,","Offset. Returns ------- tablesample An object containing the result. For more information, see","Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str","vColumn to the vDataFrame by using an advanced analytical function on a specific","self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\",","[self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---# def","n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in the","def drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the","minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage","of one of the dummies ({name}).\\n\" \"It can be the result of using","# data transformation operations, and offers beautiful graphical options. # # VerticaPy aims","== \"median\") else \"AVG\" if by == []: if fun == \"AVG\": val",") name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\")","assert response, ParameterError( \"Parameter 'response' can not be empty in case of discretization","\"cut only works on numerical / date-like vColumns.\" ) assert len(breaks) >= 2,","vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame.","-------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on an aggregation.","str, optional The method to use to discretize the vColumn. auto : Uses","copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters","axes object, optional The axes to plot on. **style_kwds Any optional parameter to","Divides the vColumn by the input element. Parameters ---------- x: float Input number.","is only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct()","8, cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box","records are in the vColumn and it returns the new vDataFrame of the","{}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for","be closed. If set to True, the intervals will be closed on the","be greater or equals to 2 in case of discretization using the method","{1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH","vColumn bar width. Parameters ---------- method: str, optional Method to use to compute","result = [distinct_count, self.count()] + [item[1] for item in query_result] index = [\"unique\",","6, h: float = 0, pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\"","avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else: final_transformation = [ (","float If the vColumn type is date like (date, datetime ...), the parameter","---# def cut( self, breaks: list, labels: list = [], include_lowest: bool =","transform the vColumn. abs : absolute value acos : trigonometric inverse cosine asin","can not be empty in case of discretization using the method 'smart'.\" )","Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]),","optional Maximum number of the vColumn distinct elements to be used as categorical","self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() <","datetime.date] = \"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","+= [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] +=","has already the alias of one of the dummies ({name}).\\n\" \"It can be","False otherwise. Returns ------- bool True if the vColumn is numerical. See Also","---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input","make the vDataFrame \"heavier\" if it is used to compute other vColumns. Parameters",") distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or","the already computed aggregations to gain in performance. The catalog will be updated","\", \".join([quote_ident(column) for column in by]) ) if (by) else \"\" ) order_by_ts","Z-Score - The MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self","gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin =",": Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\",","or numerical. q: tuple, optional Tuple including the 2 quantiles used to draw","|____/ / / # _____________ / / # \\ / / / #","{} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in","title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method != \"numerical\")) or","Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum :","self.parent See Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap","return self.iloc(limit=limit) # ---# def hist( self, method: str = \"density\", of: str","> 0: column = args[0] elif \"column\" in kwargs: column = kwargs[\"column\"] else:","Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode :","Parameters ---------- dropna: bool, optional If set to True, NULL values will not","= ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN","\"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk = \"\" if (k","bars. It is only valid if the vColumns are numerical. Optimized h will","\"\"\" if isinstance(method, str): method = method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\",",": Applies functions to the input vColumns. vDataFrame.applymap : Applies a function to","\"float\" elif method == \"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype","min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile","_verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias,","[ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]),","(pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x","\"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if the","forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool","else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS","this parameter to False, the function's performance can drastically decrease. Returns ------- int","argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function","self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be numerical\" ) cast","a new vColumn to the vDataFrame by using an advanced analytical function on","else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self,","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers","\"''\") ) ) # ---# def str_slice(self, start: int, step: int): \"\"\" ---------------------------------------------------------------------------","copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name of the","title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in","the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies","boolean. vDataFrame[].isdate : Returns True if the vColumn category is date. \"\"\" return","else \"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return","[0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center","Normalization using the MinMax (min and max). (x - min) / (max -","\"[AsType]: The vColumn {} was converted to {}.\".format( self.alias, dtype ) ) return","\".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If","= [] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix)","'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the","the mean encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\",","Parameters ---------- ts: str TS (Time Series) vColumn to use to order the","------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches","<= 0: if nbins <= 0: h = self.numh() else: h = (self.max()","or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\", val, [list])])","WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \",","library with scikit-like functionality for conducting # data science projects on data stored","if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return","[self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias) )","multiple statistical aggregations: min, max, median, unique... depending on the input method. Parameters","# ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None),","able to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The","vColumn alias. transformations: list, optional List of the different transformations. Each transformation must","pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None): return pre_comp assert","vColumn to use to partition the data. bandwidth: float, optional The bandwidth of","= \"MEDIAN\" if (method == \"median\") else \"AVG\" if by == []: if","\" \"issue.\" ) for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix,","with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the","check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]),","elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT","new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0],","Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot of","{}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title = \"Describes the statics of","if (k < 1) else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS","self, alias: str, transformations: list = [], parent=None, catalog: dict = {} ):","optional Maximum number of distinct elements for vColumns 1 and 2 to be","/ MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME ZONE","outlier). \"\"\" if isinstance(method, str): method = method.lower() check_types( [ (\"method\", method, [\"winsorize\",","self, method: str = \"zscore\", by: list = [], return_trans: bool = False","total += nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems","title=\"Computing the different categories to normalize.\", method=\"fetchall\", ) for i in range(len(result)): if","Bar Chart of the input vColumns based on an aggregation. \"\"\" check_types( [","str, optional The method to use to aggregate the data. count : Number","absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the","if method == \"auto\": method = \"mean\" if (self.isnum() and self.nunique(True) > 6)","(method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result =","------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the input","Renames the vColumn by dropping the current vColumn and creating a copy with","------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna:","[str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if","def discretize( self, method: str = \"auto\", h: float = 0, nbins: int","# ---# def plot( self, ts: str, by: str = \"\", start_date: Union[str,","Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian","\"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\", \"float\", ) ]","/ TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns -------","CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events","\"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]),","h > 0.0001: h = round(h, 4) elif h > 0.000001: h =","float = 4.0, use_threshold: bool = True, alpha: float = 0.05, ): \"\"\"","median and two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn","int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by","\\ # \\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\","---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns -------","vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates","as an outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha'","method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ]","the vColumn. The vColumn will be transformed. Parameters ---------- start: int Start of","[str]), (\"start\", start, [bool]), ] ) start_or_end = \"START\" if (start) else \"END\"","the power of another number round : rounds a value to a specified","+= ( \" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None)) else","the vColumn and it returns the new vDataFrame of the search. Parameters ----------","(0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] =","column must be numerical to use a mean encoding\" ) max_floor = len(self.parent[response].transformations)","to be used as categorical (No h will be picked or computed) h:","start: int Start of the slicing. step: int Size of the slicing. Returns","of the vColumn. The aggregations used are the median and two input quantiles.",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut(","pt_events FROM ({}) x\".format( self.alias, query, ) query = \"SELECT {} AS index,","check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\",","WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp +","\"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1,","the vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\"","= method.lower() if self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not","float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x:","------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn.","(float, int))) else \"\" ) upper_when = ( \"WHEN {} > {} THEN","**kwargs Any optional parameter to pass to the geopandas plot function. For more","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns","\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER",") ) return self.parent # ---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates",") distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and","i] THEN argv[2 * i + 1] ... ELSE argv[n] END Returns -------","in the vColumn and it returns the new vDataFrame of the search. Parameters","sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[","specific records are in the vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val,","if (category in (\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias),","[sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"]","), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: avg,","usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \"\"\"","ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct","Computes the number of matches for the regular expression in each record of","\"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range","= float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str = \"auto\",","method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) #","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the","--------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int, optional Number","in Vertica, taking advantage Vertica’s # speed and built-in analytics and machine learning","\"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ] )","method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]),","[float, int])]) assert (lower != None) or (upper != None), ParameterError( \"At least","PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75)","for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype,","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest :","bandwidth: float = 1.0, kernel: str = \"gaussian\", nbins: int = 200, xlim:","COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP","boxplot( self, by: str = \"\", h: float = 0, max_cardinality: int =","float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0","NULL, 0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if","to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias),","# ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0]","result[0][0] if not (dropna): n = \"\" if (n == 1) else str(int(n))","numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" ---------------------------------------------------------------------------",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self):","and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\"","self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods","be gathered together to create a new category : 'Others'. cat_priority: list, optional","if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826 elif","fillna( self, val=None, method: str = \"auto\", expr: str = \"\", by: list","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\",","generated will look like: even: CASE ... WHEN vColumn = argv[2 * i]","of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \"\"\" check_types([(\"limit\",","Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert","0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float,","0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0","- sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except: pass if method ==","be defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality: int,","gain in performance. The catalog will be updated when the parent vDataFrame is","method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if","most occurent elements to return. dropna: bool, optional If set to True, NULL","/ # \\ / / / # \\_______/ / / # ______ /","( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\",","used to name the new categories. If empty, names will be generated. include_lowest:","verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim,","right: bool, optional How the intervals should be closed. If set to True,","all the vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func, str_sql):","else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS NOT NULL\".format(self.alias) if (dropna)","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\"","could work if it is part of the DB version you are using.","new_category: str = \"Others\", RFmodel_params: dict = {}, response: str = \"\", return_enum_trans:","distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result for","transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn)","max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ]","response is numerical (except ints and bools), a RF Classifier otherwise. Example: Write","[str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime,","str = \"gaussian\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds,","\"{}\") self.apply(func=func) return self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","# ---# def iloc(self, limit: int = 5, offset: int = 0): \"\"\"",": Keeps the topk most frequent categories and merge the other into one","check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if offset < 0: offset","of the learning and scoring phases. xlim: tuple, optional Set the x limits","AND {}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) )","element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias, conj, )","\"\" ) upper_when = ( \"WHEN {} > {} THEN {} \".format(\"{}\", upper,","\"\", by: list = [], order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills","was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns","in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right:","= ctype # ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific","\"float\"]: warning_message = ( \"label_encode is only available for categorical variables.\" ) warnings.warn(warning_message,","by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts,","______ __ __ __ __ __ __ __ # /\\ \\ / /","1 if drop_first else 0 for k in range(len(distinct_elements) - n): name =","vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return",": Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace :","equal frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0] for elem in result]",": List of the different transformations. \"\"\" # # Special Methods # #","* result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER","Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \"\"\" if \"agg\"","the vColumns outliers using the input method. Parameters ---------- method: str, optional Method","{} IS NOT NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,","Applies a function to the vColumn. \"\"\" check_types( [ ( \"func\", func, [","not use this file except in compliance with the License. # You may","def get_dummies( self, prefix: str = \"\", prefix_sep: str = \"_\", drop_first: bool","result if elem[2] != None ] ), ) executeSQL( \"SELECT {}, {} FROM","value acos : trigonometric inverse cosine asin : trigonometric inverse sine atan :","self.parent # ---# def nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the","self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by,","the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and 2","x, [int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else \"\"","= 0 all_partition = by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition","to use to partition the data. h: float, optional Interval width if the","return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for elem in","ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 ) result =","Warning) return self elif n == 1: try: result = executeSQL( \"SELECT {},","be numerical for Normalization\") return self.parent # ---# def nsmallest(self, n: int =","elem[1] != None ] ), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0], \",","\"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes","FROM {} WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY","1)\" elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method ==","x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the vColumn.","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar","self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns","Numerical vColumn to use when the parameter method is set to 'cat_stats'. Returns","{}, {} AS ord, {}::int AS {} FROM {}\".format( trans, self.alias, self.alias, y,","this parameter will increase the precision but will also increase the time of","approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","= \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool = False, ax=None,","return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace: str,","/\\ \"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\","/ {}) * {} || ';' || (FLOOR({} / {}) * {} +","self.alias, n ) title = \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query,","= \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS","or not (labels), ParameterError( \"Length of parameter breaks must be equal to the","6, new_category: str = \"Others\", RFmodel_params: dict = {}, response: str = \"\",","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---#","Exception as e: raise ConversionError( \"{}\\nThe vColumn {} can not be converted to","than November 1993 the 3rd. area: bool, optional If set to True, draw","elem in result] elif self.isnum() and method in (\"same_width\", \"auto\"): if not (h)","0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method","agreed to in writing, software # distributed under the License is distributed on","return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self,","AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += (","assert x != 0, ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} /",") ) elif method == \"mean\": query = \"WITH vdf_table AS (SELECT *","by: list = [], return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the","function to the vColumn. Parameters ---------- func: str Function to use to transform","to find the most relevant interval to use for the discretization. topk :","expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the","you are using. Returns ------- tablesample An object containing the result. For more","def median( self, approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","\", \".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError(","meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]),","of the slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent","None avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\",","------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","ord, {}::int AS {} FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), )","\"float\", \"float\", ) ] if method != \"robust_zscore\": max_floor = 0 for elem","title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075,","feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return self.parent","Maximum number of distinct elements for vColumns 1 and 2 to be used","expression in each record of the vColumn. vDataFrame[].extract : Extracts the regular expression","order the data\" ) desc = \"\" if (method in (\"ffill\", \"pad\")) else","Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional","convert the vColumn. If this parameter is equal to 0, an optimised interval","in the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops","\", \".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode = get_dummies # ---#","trans = ( \"(CASE WHEN {} IN ({}) THEN {} || '' ELSE","aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n,","\"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and","nbins: int, optional Number of bins used for the discretization (must be >","Clips the vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha)","(pre_comp != None): return pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must be","def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness","in the final generated SQL code. Note: Dropping a vColumn can make the","( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] +","max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \"","/ # \\ / / / # \\/ / / # / /","self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int = 1):","of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of,","self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) # ---#","in case of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)","AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY","self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"]","only available on type numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\",","[str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def","[bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in","float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","min : minimum mode : most occurent element percent : percent of non-missing",": logarithm log10 : base 10 logarithm mod : remainder of a division","prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"',","= \"NULL\" if (elem[1] == None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {},","LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the","\\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # # ---#",": Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using","float = 1.0, kernel: str = \"gaussian\", nbins: int = 200, xlim: tuple","tuple] = (6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds,","input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x,","on an aggregation. Parameters ---------- method: str, optional The method to use to","and two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to","= 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to the vColumn {}","self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif method ==","self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn","sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \"\"\"","\"\" if (h > 1) or (self.category() == \"float\"): trans = ( \"'['","\"top\" in elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem ==","a default function to the vColumn. Parameters ---------- func: str Function to use","self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias),","func: str Function to use to transform the vColumn. abs : absolute value","elem[2] != None ] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT","# ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() #","func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\".format( \"{}\",","self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar)))","return \"({} - {}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero)","the next whole number cos : trigonometric cosine cosh : hyperbolic cosine cot","result], \"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2], 3)) for item in","if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by,",": product range : difference between the max and the min sem :","min, max, median, unique... depending on the input method. Parameters ---------- method: str,","float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame","Special Methods # # ---# def __init__( self, alias: str, transformations: list =","count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns","the vColumn using 'count' (Number of non-Missing elements). Returns ------- int number of","Of Evidence (WOE) Table. It tells the predictive power of an independent variable","sauv[\"min\"] ) except: pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] =","!= None ] ), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join(","prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already","\"The parameter 'numcol' must be a vDataFrame column if the method is 'cat_stats'\"","FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the","-------- vDataFrame[].ctype : Returns the vColumn database type. \"\"\" return self.transformations[-1][2] # ---#","title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM {}{}","\"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] +","func: str, Function in pure SQL used to transform the vColumn. The function","'sem' (standard error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate",") except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\",","ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time series.","[0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by,","[store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies","[bool]), (\"n\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\")","= argv[2 * i] THEN argv[2 * i + 1] ... END odd","return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat: str):","AS Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table","h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","of matches for the regular expression in each record of the vColumn. vDataFrame[].str_replace","will be transformed. Parameters ---------- start: int Start of the slicing. step: int","smart : Uses the Random Forest on a response column to find the","gathered together to create a new category : 'Others'. cat_priority: list, optional List","\" ELSE NULL END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans","step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters","\\ \\ \\/\\ \\ \\ \\ \\____ \\ \\ \\_\\ \\ \\ \\","str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of","3rd. area: bool, optional If set to True, draw an Area Plot. step:","in each of the vColumn record by an input value. The vColumn will","= 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message =","Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str,","[int, float]), (\"offset\", offset, [int, float])]) if offset < 0: offset = max(0,","return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {} AS ord, {}::int","Returns the n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns","float]), (\"numcol\", numcol, [str]), ] ) method = method.lower() assert (method != \"cat_stats\")","transform the vColumn. The function variable must be composed of two flower brackets","GROUP BY 1\".format( self.alias, y, y, query, ) query = \"SELECT {}, ord,","vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple children vColumns","the outliers by the NULL value. winsorize : Clips the vColumn using as","parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias,","smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str =","bools), a RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train","= {}, format = 'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ]","\"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill then","if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) #","non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\",","= \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of the","Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate","(Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame","\\ \\ \\ \\-. \\ # \\ \\__| \\ \\_____\\ \\ \\_____\\ \\","Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See","occurent element percent : percent of non-missing elements q% : q quantile (ex:","of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method ==","to {}.\".format( self.alias, dtype ) ) return self.parent except Exception as e: raise","= \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the","\"Can not normalize {} using the MIN and the MAX. MAX = MIN","== \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}'","import Iterable from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities","optimized h will be computed. ax: Matplotlib axes object, optional The axes to","considered as categorical. numcol: str, optional Numerical vColumn to use when the parameter","equals to 2 in case of discretization using the method 'smart'.\" ) assert","and # limitations under the License. # # |_ |~) _ _| _","partitioned by the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns","Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name","= 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters","self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers :","try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])","AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4}","dtype ) ) # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn","elements to return. dropna: bool, optional If set to True, NULL values will","TypeError( \"The response column must be numerical to use a mean encoding\" )","True, NULL values will not be considered during the computation. Returns ------- tablesample","self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\")","using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes","next whole number cos : trigonometric cosine cosh : hyperbolic cosine cot :","Global Outliers. \"\"\" if isinstance(by, str): by = [by] check_types( [ (\"method\", method,","> {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha =","nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin ==","def spider( self, by: str = \"\", method: str = \"density\", of: str","{})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\"",") ] else: warning_message = \"Can not normalize {} using a Robust Z-Score","to partition the data. bandwidth: float, optional The bandwidth of the kernel. kernel:","max_cardinality: query += ( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS","Warning : SQL code generation will be slower if the vDataFrame has been","drawn. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","[ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\",","WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias,",") else: raise TypeError(\"The vColumn must be numerical for Normalization\") return self.parent #","return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str): \"\"\" ---------------------------------------------------------------------------","USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75)","= sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h =","unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index = [","0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <= 0:","length of parameter 'labels' + 1 or parameter 'labels' must be empty.\" )","x: float A float between 0 and 1 that represents the quantile. For","columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index =","vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field from","= True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args,","\"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\":","step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self,","MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND","= [ item[0] for item in executeSQL( query=query, title=\"Computing the average of the","\".join(by) ), ) else: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format(","self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \"SELECT {} FROM","or not (is_numeric) or (method == \"categorical\") ): query = \"\"\"(SELECT {0} ||","input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality,","transformed using a mean encoding with {} as Response Column.\".format( self.alias, response )","assert self.isnum() or self.isdate(), ParameterError( \"numh is only available on type numeric|date\" )","OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method in","Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes","method == \"zscore\": if n == 0: nullifzero = 0 avg, stddev =","encoding of a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) #","their respective average. null : Replaces the outliers by the NULL value. winsorize","math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [","to compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =","Also -------- vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum","to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\",","dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number","NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias,","the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid","to the lower bound itself and the values higher than the upper bound","filter the data when 'ts' is greater than November 1993 the 3rd. area:","\", \".join(by) ), ) else: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY","returned. By setting this parameter to False, the function's performance can drastically decrease.","int = -1, k: int = 6, new_category: str = \"Others\", RFmodel_params: dict","options. # # VerticaPy aims to do all of the above. The idea","(\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements =","(PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method in (\"ffill\",","\"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations","response_cat == [0, 1], TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y)","n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See","(\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\"","avg # ---# def bar( self, method: str = \"density\", of: str =","\"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\"","cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \"MAX({}) OVER (PARTITION","= \"::float\" if self.category() == \"float\" else \"\" if index < 0: index","if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha =","write the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of the","x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self, n:","0: limit = 0 limit = \" LIMIT {}\".format(limit) else: limit = \"\"","categorical : Uses only categorical aggregations during the computation. cat_stats : Computes statistics","null, 1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns used","plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot","Computes the optimal vColumn bar width. Parameters ---------- method: str, optional Method to","WHEN \" + \" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def","TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct()","if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT","\"avg\", \"median\"): fun = \"MEDIAN\" if (method == \"median\") else \"AVG\" if by","encoding of a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]),","vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func = str(func)","h <= 0: if nbins <= 0: h = self.numh() else: h =","used for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid","= \"auto\", max_cardinality: int = 6, numcol: str = \"\" ): \"\"\" ---------------------------------------------------------------------------","True if the vColumn category is date. vDataFrame[].isnum : Returns True if the","the vColumn by transforming the values lesser than the lower bound to the","sem : standard error of the mean skewness : skewness sum : sum","query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query )","{}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias,",") self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name,",") return parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold:","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def","non-Missing elements). Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate","ln : natural logarithm log : logarithm log10 : base 10 logarithm mod","discretization. topk : Keeps the topk most frequent categories and merge the other","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the","The idea is simple: instead of moving # data around for processing, VerticaPy","donut : Donut chart. rose : Rose chart. It can also be a","in kwargs: column = kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column) column","distribution to identify outliers. After normalizing the data (Z-Score), if the absolute value","name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model","Interpolation). mean : Average. median : median. mode : mode (most occurent element).","axes to plot on. **style_kwds Any optional parameter to pass to the Matplotlib","-------- vDataFrame.astype : Converts the vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype,","* ## # # __ __ ______ ______ __ __ __ __ __","if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try:",") else: for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations +=","Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame","WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT {}","\\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\ # \\ \\ \\'/ \\","\"WHEN {} > {} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int)))","p_alpha, p_1_alpha, \"{}\" ) ) elif method == \"mean\": query = \"WITH vdf_table","self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the vColumn element.\",","will be gathered together to create a new category : 'Others'. cat_priority: list,","\" if len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One","TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the","[int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans,","None ] ), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [","None else \"NULL\", elem[2] if elem[2] != None else \"NULL\", ) for elem","\".join([quote_ident(column) + desc for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS)","/ ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS /","method will return the transformation used instead of the parent vDataFrame. This parameter","and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query","5). of: str, optional The vColumn to use to compute the aggregation. h:","element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def __len__(self): return int(self.count())","\"\"\" if isinstance(by, str): by = [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\",","[bool]))]) prefix = \"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x *","= vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\":","= self.count() if (method == \"mode\") and (val == None): val = self.mode(dropna=True)","---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input","Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad","type must be date like (date, datetime, timestamp...) or numerical. q: tuple, optional","\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events","\"max\"]).values[self.alias] if cmax - cmin == 0: warning_message = \"Can not normalize {}","vColumn records by an input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step,","types to varchar. same_freq : Computes bins with the same number of elements.","ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---#","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\"","\"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\",","and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM","except Exception as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn","< {} THEN {} WHEN {} > {} THEN {} ELSE {} END)\".format(","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product","\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index,","very useful for testing to be able to look at the final transformation.","print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias,","this method will return the mode of the vColumn. Returns ------- str/float/int vColumn","return store_usage # ---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the","on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,","(\"float\", \"int\") # ---# def iv_woe(self, y: str, nbins: int = 10): \"\"\"","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str):",": Returns the n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query","record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each","in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs):","For example, to check if Badr and Fouad are in the vColumn. You","/ / / # |____/ / / # _____________ / / # \\","\" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE","NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title","category is date. \"\"\" return self.category() in (\"float\", \"int\") # ---# def iv_woe(self,","if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return","max_cardinality + 1) and (method != \"numerical\")) or not (is_numeric) or (method ==","Value (IV) / Weight Of Evidence (WOE) Table. It tells the predictive power","Returns the tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset,","Returns ------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin :","verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in kwargs): from","return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn","str, optional vColumn to use to partition the data. method: str, optional The","(self.isnum() and self.nunique(True) > 6) else \"mode\" total = self.count() if (method ==","the different records. For example, to check if Badr and Fouad are in","float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x:","+ 2\". copy_name: str, optional If not empty, a copy will be created","[str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins,","'k' must be greater or equals to 2 in case of discretization using","store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the","DB type. Returns ------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype =","on an aggregation. Parameters ---------- by: str, optional vColumn to use to partition","be updated when the parent vDataFrame is modified. Attributes ---------- alias, str :","list, labels: list = [], include_lowest: bool = True, right: bool = True,","std). (x - avg) / std robust_zscore : Normalization using the Robust Z-Score","of matches for the regular expression in each record of the vColumn. The","transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn","an independent variable in relation to the dependent variable. Parameters ---------- y: str","self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field from the","\"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\", \"float\", ) ] elif method","vDataFrame represents the entire relation, a vColumn can be seen as one column","# ---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the","self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\",","range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} =>","(\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method = method.lower() assert","isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\",","\" DESC\" partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in","\\/_/ \\/_/ # # # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which","ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk,","to_replace: str Regular expression to replace. value: str, optional New value. Returns -------","result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the","bool, optional Drops the first dummy to avoid the creation of correlated features.","\"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x)","UNION ALL \".join(query) ) title = \"Describes the statics of {} partitioned by","The less frequent elements will be gathered together to create a new category",": average absolute deviation approx_unique : approximative cardinality count : number of non-missing","total) / self.parent.shape()[0] ) except: pass total = int(total) conj = \"s were","cast, ) tmp_query += ( \" WHERE {} IS NULL\".format(self.alias) if (category in","limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if self.category() ==","return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the","(WOE) Table. It tells the predictive power of an independent variable in relation","global outlier). \"\"\" if isinstance(method, str): method = method.lower() check_types( [ (\"method\", method,","= method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp !=","# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in","be greater or equal to 2.\" ) assert len(breaks) == len(labels) + 1","> 1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was","[2018-2022] Micro Focus or one of its affiliates. # Licensed under the Apache","to varchar. same_freq : Computes bins with the same number of elements. same_width","return \"({} - {}) / ({})\".format(self.alias, med, mad) else: final_transformation = [ (","self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \" WHERE {} IS NULL\".format(self.alias)","= round(h, 6) if self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end =","Verifies if the regular expression is in each of the vColumn records. The","# ---# def nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n","{}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except:","the vColumn. Parameters ---------- limit: int, optional Number of elements to display. Returns","---------- breaks: list List of values used to cut the vColumn. labels: list,","/ ({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool = True): \"\"\" ---------------------------------------------------------------------------","the input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent","only valid if the vColumns are numerical. Optimized h will be computed if","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe :","Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","mean encoding was successfully done.\") return self.parent # ---# def median( self, approx:","\"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str,","[str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem","of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use","categorical (No h will be picked or computed) ax: Matplotlib axes object, optional","the categorical vColumns. bfill : Back Propagation of the next element (Constant Interpolation).","= \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias])","total += sys.getsizeof(elem) return total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","histogram of the vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method,","corresponds to an aggregation. vColumns will memorize the already computed aggregations to gain","bandwidth of the kernel. kernel: str, optional The method used for the plot.","as percents. Parameters ---------- k: int, optional Number of most occurent elements to","Fouad are in the vColumn. You can write the following list: [\"Fouad\", \"Badr\"]","able to solve this issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for","DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query,","{} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias,","[ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ),","\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table","\"\"\" return self.iloc(limit=limit) # ---# def hist( self, method: str = \"density\", of:","occurent elements, how often they occur, and other statistical information. Parameters ---------- k:","a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first,","Outliers. \"\"\" if isinstance(by, str): by = [by] check_types( [ (\"method\", method, [\"zscore\",",": Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True if","'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS","to use to discretize the vColumn. auto : Uses method 'same_width' for numerical","in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)","tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError(","information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of","vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to replace. value:","k most occurent elements and their distributions as percents. Parameters ---------- k: int,","def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent","vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount of expressions.","set to True, NULL values will not be considered during the computation. Returns","{}({}) FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result","try: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {} IS","{} (response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"]","{})\".format( self.alias, \", \".join(by) ), ) else: cmax, cmin = ( \"MAX({}) OVER","other into one unique category. h: float, optional The interval size to convert","the vDataFrame parent and do not apply it. This parameter is very useful","new vColumn labeled with 0 and 1 (1 meaning global outlier). \"\"\" check_types(","str) or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\", val,","= result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)),","+ index, \"value\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method","more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part","result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns","Series of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut :","vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn.","relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias: str vColumn","all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k","element (ex: top1 for the mode) topk_percent : kth most occurent element density","{}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias,","numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during the computation.","ParameterError(\"Parameter 'n' must be greater or equal to 1\") where = \" WHERE","float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame","\"donut\", \"rose\"]), ] ) donut = True if pie_type == \"donut\" else False","{0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET","of most occurent elements to return. dropna: bool, optional If set to True,","list List of values used to cut the vColumn. labels: list, optional Labels","self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for","{}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ),","self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def","float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median,","input value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression","= True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn","str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the first","---# def __init__( self, alias: str, transformations: list = [], parent=None, catalog: dict","empty\\nIf you want to normalize by grouping by elements, please use a method","used to transform the vColumn. The function variable must be composed of two","be filtered. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns the","k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")]","= [order_by] check_types( [ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\",","{}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET","input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---#","# ---# def discretize( self, method: str = \"auto\", h: float = 0,","Fills the vColumns outliers using the input method. Parameters ---------- method: str, optional","input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5):","drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result + [self.max()] elif method","vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn)","skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","in sublist] # ---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn","method: str, optional The method to use to discretize the vColumn. auto :","len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes","has already the alias {name}.\\nBy changing the parameter 'name', you'll be able to","Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully","the range plot of the vColumn. The aggregations used are the median and",") if (is_date) and not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"])","Function to use to transform the vColumn. abs : absolute value acos :","self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum).","= to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method !=",": number of non-missing elements cvar : conditional value at risk dtype :","\"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2,","the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a","{} AS ord, {}::int AS {} FROM {}\".format( trans, self.alias, self.alias, y, y,","or computed) ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","See Also -------- vDataFrame.filter: Filters the data using the input expression. \"\"\" self.parent.filter(\"{}","percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS","self.parent # ---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for","# \\ / / / # \\ / / / # \\_______/ /","BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER","(n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode","total, query, nth_elems = nb, [], [] while total < int(float(count / int(nbins)))","Applies a function to all the vColumns. vDataFrame.eval : Evaluates a customized expression.","max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category","It can also be a cutomized aggregation (ex: AVG(column1) + 5). of: str,","KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name = gen_tmp_name(schema=schema,","= \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method:","{} was converted to {}.\".format( self.alias, dtype ) ) return self.parent except Exception","), \"float\", \"float\", ) ] if method != \"robust_zscore\": max_floor = 0 for","check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\",","---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype","together to create a new category : 'Others'. cat_priority: list, optional List of","is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the","input vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn to","def topk(self, k: int = -1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns","max_cardinality: int, optional Cardinality threshold to use to determine if the vColumn will","1 elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]:","[elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if","Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns -------","for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if","None: warning_message = \"The vColumn {} has no mode (only missing values).\\nNothing was","histogram of the vColumn based on an aggregation. \"\"\" check_types( [ (\"by\", by,","the vColumn using an input 'quantile'. Parameters ---------- x: float A float between","__ __ __ # /\\ \\ / / /\\ ___\\ /\\ __ \\","pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing","---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input","alias {new_name}.\\nBy changing the parameter 'new_name', you'll be able to solve this issue.\"","if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"]","== None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \",","\"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn","to_tablesample(query, title=title) # ---# def numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes","= self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn {} must be","else \"\" if index < 0: index += self.parent.shape()[0] query = \"SELECT {}{}","For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\"","BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \",","\"Not enough values to compute the Equal Frequency discretization\" ) total, query, nth_elems","# ---# def density( self, by: str = \"\", bandwidth: float = 1.0,","max_cardinality: int = 6, nbins: int = 0, h: float = 0, ax=None,","1: try: result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY","the information will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent","0, pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie","the alias {name}.\\nBy changing the parameter 'name', you'll be able to solve this","\"<\", \"]\" if labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions +=","outliers. After normalizing the data (Z-Score), if the absolute value of the record","not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias {new_name}.\\nBy changing the parameter","self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT","vColumns based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method,","fill_outliers( self, method: str = \"winsorize\", threshold: float = 4.0, use_threshold: bool =","WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See","verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import *","try: try: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {}","\"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r = \"<=\", \"<\", \"[\",","else the lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution","to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent","xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, )","- min) by: list, optional vColumns used in the partition. return_trans: bool, optimal","self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality,","mechanism to sequentialize # data transformation operations, and offers beautiful graphical options. #","float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","\"The response column must be numerical to use a mean encoding\" ) max_floor","+= self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit","index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ]","be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also --------","{} was transformed using a mean encoding with {} as Response Column.\".format( self.alias,","vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes","\"\"\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on an","[str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\",","int Slice size. unit: str, optional Slice size unit. For example, it can","self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem]","self.mode(dropna=True) if val == None: warning_message = \"The vColumn {} has no mode","/ HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM /","SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY","'x' represents the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply","list, optional List of the different transformations. Each transformation must be similar to","Also -------- vDataFrame.bar : Draws the Bar Chart of the input vColumns based","to compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct","self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of","(1 meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold,","AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS","LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \"UNION","method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used to","Returns the head of the vColumn. Parameters ---------- limit: int, optional Number of","self, method: str = \"auto\", max_cardinality: int = 6, numcol: str = \"\"","The vColumn '{}' was transformed with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"),","expression is in each of the vColumn records. vDataFrame[].str_count : Computes the number","auto : Regular pie chart. donut : Donut chart. rose : Rose chart.","\\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python","offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype()","using a Z-Score - The Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message,","{\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth,","{} + {}{}) || ']'\".format( \"{}\", h, h, \"{}\", h, h, h, floor_end","{} IS NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE {} =","---------- func: list List of the different aggregation. aad : average absolute deviation","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias,","and merge the other into one unique category. h: float, optional The interval","# ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods #","the k most occurent elements, how often they occur, and other statistical information.","events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE","\"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str,","pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the","NameError( f\"A vColumn has already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll","self, method: str = \"density\", of: str = \"\", max_cardinality: int = 6,","\".join([\"1\"] + nth_elems + [str(count)]) ) query = \"SELECT {} FROM (SELECT {},","h, h, floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({}) || ''\",","\"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY","\"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]:","(ex: top1 for the mode) topk_percent : kth most occurent element density unique","tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) /","return self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn","Returns the vColumn most occurent elements. \"\"\" if \"agg\" not in kwargs: query","total) except Exception as e: self.transformations = [elem for elem in copy_trans] raise","self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}'","bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional The method","result index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\",","while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total +=","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot :","else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import","of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates","(\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def","See Also -------- vDataFrame.astype : Converts the vColumns to the input type. \"\"\"","done.\") return self.parent # ---# def median( self, approx: bool = True, ):","\"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\":","\"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted","new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\": assert","to fill the vColumn outliers. mean : Replaces the upper and lower outliers","---------- name: str Name of the copy. Returns ------- vDataFrame self.parent See Also","---------- length: int Slice size. unit: str, optional Slice size unit. For example,",".transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return","optional Method to use to fill the vColumn outliers. mean : Replaces the","method: str = \"density\", of: str = \"\", max_cardinality: int = 6, nbins:",").format(self.alias, max_cardinality + 1) query = \"WITH vdf_table AS (SELECT * FROM {})","this parameter to False, the function's performance can drastically decrease. Returns ------- float/str","STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1)","for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info","or equals to 2 in case of discretization using the method 'topk'\" )","sys.getsizeof(elem) return total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using",") if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self,","under the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to","# \\ / # \\/ # _ # \\ / _ __|_. _","input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n ==","\"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express","\\/ / / # / / # / / # \\ / #","Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot","'name' must not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has","/ self.parent.shape()[0] ) except: pass total = int(total) conj = \"s were \"","get_dummies # ---# def head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the","descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates","{}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax,","\\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ #","text / binary / spatial / uuid / undefined Returns ------- str vColumn","unique : cardinality (count distinct) var : variance Other aggregations could work if","def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in","vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\",","represents the quantile. For example: 0.25 represents Q1. approx: bool, optional If set","to apply the function: x -> x^2 + 2 use \"POWER({}, 2) +","len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())]","[bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \"cut only","Regular pie chart. donut : Donut chart. rose : Rose chart. It can",": Applies a function to the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])])","), print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format(",": Drops the vColumn missing values. \"\"\" if isinstance(by, str): by = [by]","like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to use to",") assert self.isnum() or self.isdate(), TypeError( \"cut only works on numerical / date-like","] expr = \"CASE WHEN \" + \" WHEN \".join(conditions) + \" END\"","{}) * {} + {}{}) || ']'\".format( \"{}\", h, h, \"{}\", h, h,","# VerticaPy aims to do all of the above. The idea is simple:","def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 #","'response' can not be empty in case of discretization using the method 'smart'.\"","return self elif method == \"minmax\": if n == 0: nullifzero = 0","(method == \"median\") else \"AVG\" if by == []: if fun == \"AVG\":","func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat: str): \"\"\" ---------------------------------------------------------------------------","matches for the regular expression in each record of the vColumn. vDataFrame[].str_replace :","element). 0ifnull : 0 when the vColumn is null, 1 otherwise. expr: str,",") tmp_query += ( \" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\",","= self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception( \"Not","AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\".format( self.alias, y,","the vColumn 'of' (ex: 50% to get the median). It can also be","Returns the category of the vColumn. The category will be one of the","(SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE {0}","CONDITIONS OF ANY KIND, either express or implied. # See the License for","information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements","max : maximum mean : average median : median min : minimum mode",") warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\"","nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {}","self.parent[by].distinct() for idx, column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax","method is in ffill|pad|bfill|backfill then 'order_by' must be a list of at least","\"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val +=","= xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns):","numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean.","head of the vColumn. Parameters ---------- limit: int, optional Number of elements to","approximate quantile is returned. By setting this parameter to False, the function's performance","compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and","elem in order_by] + by) by = self.parent.format_colnames(by) if method == \"auto\": method","optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See","ORDER BY ord\".format( self.alias, query, ) title = \"Computing WOE & IV of","DAY / DECADE / DOQ / DOW / DOY / EPOCH / HOUR","\"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn","Aggregates the vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate","trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube root ceil","than November 1993 the 3rd. plot_median: bool, optional If set to True, the","method. auto : Sets the method to 'numerical' if the vColumn is numerical","\"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns ------- int","(labels), ParameterError( \"Length of parameter breaks must be equal to the length of",": Minimum of the vColumn 'of'. max : Maximum of the vColumn 'of'.","= 4.0, use_threshold: bool = True, alpha: float = 0.05 ): \"\"\" ---------------------------------------------------------------------------","the data when 'ts' is greater than November 1993 the 3rd. area: bool,","] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from","return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True","\"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The","(\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM","import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin","be transformed. Parameters ---------- field: str The field to extract. It must be","events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0 THEN","compliance with the License. # You may obtain a copy of the License","------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using","if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method,","assert (method != \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must be a","max and the min sem : standard error of the mean skewness :","The expression generated will look like: even: CASE ... WHEN vColumn = argv[2","vColumn is numerical. \"\"\" return self.category() == \"date\" # ---# def isin(self, val:","float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ] ) start_or_end = \"START\" if","\\-. \\ # \\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\","not (result) else result[0][0] if not (dropna): n = \"\" if (n ==","Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \"\"\"","= \"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL GROUP","# ---# def pie( self, method: str = \"density\", of: str = \"\",","using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the","range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize(","category in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100","or parameter 'labels' must be empty.\" ) conditions, column = [], self.alias for","[str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must","life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and","name. \\u26A0 Warning : SQL code generation will be slower if the vDataFrame","for elem in result] elif self.isnum() and method in (\"same_width\", \"auto\"): if not","else: warning_message = \"Can not normalize {} using a Robust Z-Score - The","for idx, column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax =","'mad' (median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate :","/ / # \\ / / / # \\ / / / #","by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else","result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp,","vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix =","method: str = \"auto\", h: float = 0, nbins: int = -1, k:","------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks","= max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT","!= None else \"NULL\", elem[1] if elem[1] != None else \"NULL\", ) for","--------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating a copy","=> {}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr,","result], \"percent\": [float(round(item[2], 3)) for item in result], } return tablesample(values) # ---#","idx, elem in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] == None) else","return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) #","WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER","-------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes","expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k],","method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values: for","to skip. Returns ------- tablesample An object containing the result. For more information,","final_transformation = [ ( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if","aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \"\"\"","Tuple including the 2 quantiles used to draw the Plot. start_date: str /","brackets {}. For example to apply the function: x -> x^2 + 2","elem == None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem]","for item in sublist] # ---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides","bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements and their","Aggregates the vColumn using 'var' (Variance). Returns ------- float var See Also --------","frequent elements will be gathered together to create a new category : 'Others'.","pie( self, method: str = \"density\", of: str = \"\", max_cardinality: int =","query = \"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM","== \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method","filter the data when 'ts' is greater than November 1993 the 3rd. plot_median:","Aggregates the vColumn using 'avg' (Average). Returns ------- float average See Also --------","parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool =","value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to","[int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates","bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity","int]), (\"upper\", upper, [float, int])]) assert (lower != None) or (upper != None),",": variance Other aggregations could work if it is part of the DB","which that stores all user transformations. If the vDataFrame represents the entire relation,","(\"h\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from","to define the outliers. After normalizing the data (Z-Score), if the absolute value","'{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts","using a time series rule. Parameters ---------- length: int Slice size. unit: str,","self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins if h","Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \"\"\" if isinstance(by, str):","# ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns -------","# Unless required by applicable law or agreed to in writing, software #","one unique category. h: float, optional The interval size to convert to use","i + 1] ... END odd : CASE ... WHEN vColumn = argv[2","= \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try:","0 all_partition = by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition +=","optional If the function has two arguments (example, power or mod), 'x' represents","nb, [], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems +=","dtype, [str])]) try: query = \"SELECT {}::{} AS {} FROM {} WHERE {}","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns","-------- vDataFrame.donut : Draws the donut chart of the vColumn based on an","evaluate the approximate density function. Increasing this parameter will increase the precision but","look like: even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2","to True, the approximate median is returned. By setting this parameter to False,","\"<\", \"[\", \"[\" if idx == 0 and include_lowest: op1, close_l = \"<=\",","steps different than 1.\" ) index_stop = index.stop index_start = index.start if not","from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in kwargs):","[sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])]","else \"mode\" total = self.count() if (method == \"mode\") and (val == None):","MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try:","] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from","PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias,","the 3rd. end_date: str / date, optional Input End Date. For example, time","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes","normalize by grouping by elements, please use a method in zscore|minmax\" warnings.warn(warning_message, Warning)","\\ /\\ \"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____ \\ \\",": trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube root","Also -------- vDataFrame.isin : Looks if some specific records are in the vDataFrame.","use when the parameter method is set to 'cat_stats'. Returns ------- tablesample An","---# def plot( self, ts: str, by: str = \"\", start_date: Union[str, datetime.datetime,","[ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[1] if","COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS","/ # ____________ ______ # / __ `\\ / / # | \\/","{} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\",","be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See","or equal to 2.\" ) assert len(breaks) == len(labels) + 1 or not","vDataFrame[].nlargest : Returns the n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])])","# ---# def str_replace(self, to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces","Parameters ---------- method: str, optional The describe method. auto : Sets the method","Parameters ---------- *args / **kwargs Any optional parameter to pass to the geopandas","Returns True if the vColumn category is date. \"\"\" return self.category() in (\"float\",","of a division operation pow : number raised to the power of another","self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is","1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when","= [elem for elem in self.transformations] total = self.count() if method not in","variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number of","int(nbins))) assert nb != 0, Exception( \"Not enough values to compute the Equal","the DB version you are using. Returns ------- tablesample An object containing the","a copy will be created using the input Name. Returns ------- vDataFrame self.parent","BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else: new_column = \"COALESCE({}, {}({})","regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn.","by: list = [], order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing","True, the record will be sliced using the floor of the slicing instead","not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix =","self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the","\"\", max_cardinality: int = 6, h: float = 0, pie_type: str = \"auto\",","{} > {} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else","in by]) ) if (by) else \"\" ) order_by_ts = \", \".join([quote_ident(column) +","testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the","method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max","\\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\","bool, optional If set to True, draw an Area Plot. step: bool, optional","logarithm log : logarithm log10 : base 10 logarithm mod : remainder of","{}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\", \"float\", )","--------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name: str",") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot","must be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat","if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\",","!\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool =","== \"topk\": assert k >= 2, ParameterError( \"Parameter 'k' must be greater or","( self.isnum() and method == \"smart\" ): n = len(result) trans = \"(CASE","be slower if the vDataFrame has been transformed multiple times, so it's better","{}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def count(self): \"\"\"","transformations. If the vDataFrame represents the entire relation, a vColumn can be seen","self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied","\"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only available on","offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit)","The integer k of the 'topk' method. new_category: str, optional The name of","= 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({})","applied to the vColumn {} using the following mapping:{}\".format( self.alias, text_info ) )","AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS","OR CONDITIONS OF ANY KIND, either express or implied. # See the License","average median : median min : minimum mode : most occurent element percent","|| '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem","mad != 0: if return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad)","'{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace: str, value: str =","if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is","\"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---#","-------- vDataFrame.bar : Draws the Bar Chart of the input vColumns based on","Parameters ---------- k: int, optional Number of most occurent elements to return. dropna:","= self.parent.format_colnames(by) if method == \"auto\": method = \"mean\" if (self.isnum() and self.nunique(True)","Also -------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \"\"\"","True, the Median will be drawn. ax: Matplotlib axes object, optional The axes","vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches for","avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\", \"float\", ) ] elif","1\".format( self.alias, y, y, query, ) query = \"SELECT {}, ord, non_events, events,","final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\",","spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds,","normalized with the method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The vColumn","\"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE) Table.","None), ParameterError( \"At least 'lower' or 'upper' must have a numerical value\" )","NOT NULL\".format(self.alias) if (dropna) else \"\" query = \"SELECT {} AS {}, COUNT(*)","must be greater or equal to 2.\" ) assert len(breaks) == len(labels) +","\"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\",","\"percent\": [float(round(item[2], 3)) for item in result], } return tablesample(values) # ---# def","0 and 1 (1 meaning global outlier). \"\"\" if isinstance(method, str): method =","check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth,","/ NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\".format( self.alias, query,","idx, column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax = self.parent.search(","cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\"))","\\ \\____ \\ \\ \\/\\ \\ \\ \\ \\____ \\ \\ \\_\\ \\","customized expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"),","val == None: warning_message = \"The vColumn {} has no mode (only missing","using the floor of the slicing instead of the ceiling. Returns ------- vDataFrame","\"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ] ) if by:","Modules # # Standard Python Modules import math, re, decimal, warnings, datetime from","object \"\"\" columns = [self.alias] check = True if len(args) > 0: column","Focus or one of its affiliates. # Licensed under the Apache License, Version","float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","to cut the vColumn. labels: list, optional Labels used to name the new","\"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the lower","\"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes","a numerical value\" ) lower_when = ( \"WHEN {} < {} THEN {}","the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int =","# ---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from","result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the","parameter to False, the function's performance can drastically decrease. Returns ------- int vColumn","the function's performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate","For example, it can be 'minute' 'hour'... start: bool, optional If set to","p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent # ---# def","avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER",") ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return self.parent #","[\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by if method in [\"ffill\", \"pad\",","using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the","of the input vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority","WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} >","slower if the vDataFrame has been transformed multiple times, so it's better practice","kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] = True if not","else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \",","\"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[1] if elem[1]","# # |_ |~) _ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_||","\"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule. Parameters","to normalize by grouping by elements, please use a method in zscore|minmax\" warnings.warn(warning_message,","return to_tablesample(query, title=title) # ---# def numh(self, method: str = \"auto\"): \"\"\" ---------------------------------------------------------------------------","self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts","\\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/","self.isnum(), self.isdate(), ) if (is_date) and not (method == \"categorical\"): result = self.aggregate([\"count\",","elem[2] if elem[2] != None else \"NULL\", ) for elem in result if","numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical","method.lower() if self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema):","See Also -------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn.","vColumn by the input element. Parameters ---------- x: float Input number. Returns -------","---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float","List of the different records. For example, to check if Badr and Fouad","be computed. pie_type: str, optional The type of pie chart. auto : Regular","not (dropna) and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\"Parameter","), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name","max_cardinality: int, optional Maximum number of the vColumn distinct elements to be used","sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] =","Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See","width bins. smart : Uses the Random Forest on a response column to","argv[2 * i + 1] ... END odd : CASE ... WHEN vColumn","+ 5). of: str, optional The vColumn to use to compute the aggregation.","even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i","self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding.","using the mean encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]),","TS. start_date: str / date, optional Input Start Date. For example, time =","0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0,","= self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \"Normalize doesn't","VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast","% len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins,","a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to","self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query","Interval width of the vColumns 1 and 2 bars. It is only valid","vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category is date.","1 ) result = executeSQL( query=query, title=\"Computing the optimized histogram nbins using Random","record is greater than the threshold, it will be considered as an outlier.","mode (most occurent element). 0ifnull : 0 when the vColumn is null, 1","vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \"\"\" check_types([(\"lower\", lower,","code. Note: Dropping a vColumn can make the vDataFrame \"heavier\" if it is","warnings, datetime from collections.abc import Iterable from typing import Union # VerticaPy Modules","Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also --------","int(nbins): nth_elems += [str(total)] total += nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format(","elif method == \"minmax\": if n == 0: nullifzero = 0 cmin, cmax","+= [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]:","method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message",".values[self.alias] ) result = [distinct_count] + result index = [ \"unique\", \"count\", \"mean\",","float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title =","else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem in copy_trans]","the vDataFrame. Dropping a vColumn means simply not selecting it in the final","method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method == \"minmax\":","self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS","False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn.","\".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] =","- ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","\"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns","outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution","vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns","[self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) )","\"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, },","float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters","if (isinstance(lower, (float, int))) else \"\" ) upper_when = ( \"WHEN {} >","and do not apply it. This parameter is very useful for testing to","float, tuple] = (None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider","non-missing elements cvar : conditional value at risk dtype : vColumn type iqr","'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date)","predictive power of an independent variable in relation to the dependent variable. Parameters","For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a","freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1 / 3)]","Copy]: A copy of the vColumn {} named {} was added to the","The aggregations used are the median and two input quantiles. Parameters ---------- ts:","def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the","the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\"",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self):","True, draw a Step Plot. ax: Matplotlib axes object, optional The axes to","result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {},","from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)","\\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\ \\ \\ \\____ \\","the vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate :","The new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy :","of parameter 'breaks' must be greater or equal to 2.\" ) assert len(breaks)","= \"auto\", expr: str = \"\", by: list = [], order_by: list =","WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE {}","alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of","(\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]), ]","'{}'.\".format(old_name, new_name) ) return parent # ---# def round(self, n: int): \"\"\" ---------------------------------------------------------------------------","xmax = self.max() else: xmin, xmax = xlim custom_lines = [] columns =","on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\",","it in the final generated SQL code. Note: Dropping a vColumn can make","= self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail","self.parent.shape()[0], numcol, cast, ) tmp_query += ( \" WHERE {} IS NULL\".format(self.alias) if","be > 1) k: int, optional The integer k of the 'topk' method.","was deleted from the vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers( self,","--------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also --------","\"\"\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by: str,","trans else: self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem]","return tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn","{}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return","vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1 (1","OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events /","int / float / text / binary / spatial / uuid / undefined","p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the","val} return self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the","(only if the vColumn type is date like). The vColumn will be transformed.","mad) else: final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\", med, mad),","FROM {} WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias,","the vColumn using 'sem' (standard error of mean). Returns ------- float sem See","unique category. h: float, optional The interval size to convert to use to","difference between the max and the min sem : standard error of the","the lower bound itself and the values higher than the upper bound to","vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality )","self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)): expr +=","--------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ---------- n: int,","Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","offset=-1) # ---# def topk(self, k: int = -1, dropna: bool = True):","field to extract. It must be one of the following: CENTURY / DAY","is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF","# limitations under the License. # # |_ |~) _ _| _ /~\\","self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \"\"\" if","raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total > 0: try: if","self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1)","mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See Also --------","( \"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\".format(","be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat =","of the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values","digits to keep after the comma. Returns ------- vDataFrame self.parent See Also --------","(byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\" import","\\/ (/_| | |(_(_|| \\/ # / # VerticaPy is a Python library","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] #","{}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {},","\"''\")) ) # ---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular","0 and 1 that represents the quantile. For example: 0.25 represents Q1. approx:","int/float, optional If the function has two arguments (example, power or mod), 'x'","{} AS {} FROM {} WHERE {} IS NOT NULL GROUP BY {}","elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample","x GROUP BY 1\".format( self.alias, y, y, query, ) query = \"SELECT {},","threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP","column if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(),","vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count,","to the vColumn. Parameters ---------- func: str Function to use to transform the","to normalize. zscore : Normalization using the Z-Score (avg and std). (x -","the bar chart of the vColumn based on an aggregation. Parameters ---------- method:","case of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name,","this method when first preparing your data. Parameters ---------- new_name: str The new","- vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 *","in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be numerical\" ) cast =","= 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END","|| '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT","is date, False otherwise. Returns ------- bool True if the vColumn category is","= self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features","vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return parent # ---# def","Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify outliers. After","+ [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0,","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If","elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing","# ---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression","stores all user transformations. If the vDataFrame represents the entire relation, a vColumn","- 1], result[i] ) trans += \" ELSE NULL END)\" trans = (trans,","you'll be able to solve this \" \"issue.\" ) for k in range(len(distinct_elements)","the vColumn using 'median'. Parameters ---------- approx: bool, optional If set to True,","Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table )","int = 6, new_category: str = \"Others\", RFmodel_params: dict = {}, response: str","if (method == \"median\") else \"AVG\" if by == []: if fun ==","else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {}","'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) #","number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","6) if self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end = -1 if","aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int,","h = self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins","'{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\":","the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent","vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\"))","\"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\":","AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table","schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\")","to convert the vColumn. If this parameter is equal to 0, an optimised","\"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]),","sum : Sum of the vColumn 'of'. q% : q Quantile of the","{}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except:","for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor","{}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord)","transformations, str : List of the different transformations. \"\"\" # # Special Methods","str Regular expression to replace. value: str, optional New value. Returns ------- vDataFrame","{}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[1] if elem[1] !=",": value up to the next whole number cos : trigonometric cosine cosh","remainder of a division operation pow : number raised to the power of","(example, power or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique...","columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed using a mean encoding","] if method != \"robust_zscore\": max_floor = 0 for elem in by: if","by the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns -------","impute the missing values. auto : Mean for the numerical and Mode for","sine atan : trigonometric inverse tangent cbrt : cube root ceil : value","{}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() )","Any optional parameter to pass to the geopandas plot function. For more information,","\"{}\", \"{}\", partition_by, order_by_ts ) if method in (\"mean\", \"median\") or isinstance(val, float):","copy of the vColumn {} named {} was added to the vDataFrame.\".format( self.alias,","of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int","in each of the vColumn records. vDataFrame[].str_count : Computes the number of matches","optional If set to True, the approximate quantile is returned. By setting this","# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #","occur, and other statistical information. Parameters ---------- k: int, optional Number of most","expression generated will look like: even: CASE ... WHEN vColumn = argv[2 *","self, by: str = \"\", bandwidth: float = 1.0, kernel: str = \"gaussian\",","model parameters used to compute the best splits when 'method' is set to","self.min()) * 1.01 / nbins if h > 0.01: h = round(h, 2)","Returns the a part of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def","self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median",": sum std : standard deviation topk : kth most occurent element (ex:","if h > 0.01: h = round(h, 2) elif h > 0.0001: h","\"bfill\", \"backfill\"]: all_partition += [elem for elem in order_by] for elem in all_partition:","= aggregate # ---# def apply(self, func: str, copy_name: str = \"\"): \"\"\"","for processing, VerticaPy brings the logic to the data. # # # Modules",": Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold","\"winsorize\", threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05,","a vColumn can be seen as one column of that relation. vColumns simplify","'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception","float])]) query = \"SELECT * FROM {} WHERE {} IS NOT NULL ORDER","right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input","the new vDataFrame of the search. Parameters ---------- val: list List of the","\"Can not normalize {} using a Z-Score - The Standard Deviation is null","(unit: b). Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage","of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of,","vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\"","geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args /","BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads","width of the bar. If empty, an optimized h will be computed. pie_type:","DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() )","-> x^2 + 2 use \"POWER({}, 2) + 2\". copy_name: str, optional If","limit: int = 5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part","result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table =","{} has no mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning)","Slices the vColumn using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\"))","by the NULL value. winsorize : Clips the vColumn using as lower bound","vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self,","[], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot of the vColumn.","{}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1] for item in query_result]",": hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent tanh","case of discretization using the method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response'","RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model","sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total","case of discretization using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans =","5): \"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int,","self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]:","---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float","method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826 elif method","= False, step: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies","| |(_(_|| \\/ # / # VerticaPy is a Python library with scikit-like","the spider plot of the input vColumn based on an aggregation. Parameters ----------","{} < {} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else","/ DAY / DECADE / DOQ / DOW / DOY / EPOCH /","kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10)","Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number of nbins",") elif self.isnum() and method == \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter","vColumn using an input 'quantile'. Parameters ---------- x: float A float between 0","len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor):","kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self,","usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage","10. response: str, optional Response vColumn when method is set to 'smart'. return_enum_trans:","\"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\",","upper ZScores. threshold: float, optional Uses the Gaussian distribution to define the outliers.","self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception","tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \"\"\"","information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the","f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE","\"float\", ) ] if method != \"robust_zscore\": max_floor = 0 for elem in","elif method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ]","percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING","length: int Slice size. unit: str, optional Slice size unit. For example, it","(\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date,","= (None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of","RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random","# | \\/ / / / # |______ / / / # |____/","ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality:","list, optional List of the different categories to consider when drawing the box","vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See","input method. Parameters ---------- method: str, optional The describe method. auto : Sets","!= None) or (upper != None), ParameterError( \"At least 'lower' or 'upper' must","* i] THEN argv[2 * i + 1] ... ELSE argv[n] END Returns","\"median\") or isinstance(val, float): category, ctype = \"float\", \"float\" elif method == \"0ifnull\":","= \"float\", \"float\" elif method == \"0ifnull\": category, ctype = \"int\", \"bool\" else:","int/float/tuple, optional Interval width of the vColumns 1 and 2 bars. It is","to use to impute the missing values. auto : Mean for the numerical","------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the","{} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent","[dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins,","\"NULL\" if (elem[1] == None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format(","elem in result if elem[2] != None ] ), ) executeSQL( \"SELECT {},","pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut = True if pie_type == \"donut\"","100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q: tuple =","__setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # # ---# def","self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] =","0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\",","set to 'cat_stats'. Returns ------- tablesample An object containing the result. For more","h, floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({}) || ''\", \"varchar\",","\"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str",") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max -","column 'numcol' must be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else \"\"","\"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in","the lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution to","\"float\", \"float\" elif method == \"0ifnull\": category, ctype = \"int\", \"bool\" else: category,","List of the different aggregation. aad : average absolute deviation approx_unique : approximative","time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date,","for the categorical vColumns. bfill : Back Propagation of the next element (Constant","Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n","for item in executeSQL( query=query, title=\"Computing the average of the {}'s lower and","[bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by)","a list of at least one element to use to order the data\"","/ # ______ / / # \\ / / / # \\ /","absolute deviation approx_unique : approximative cardinality count : number of non-missing elements cvar","close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r =","\".\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int","upper bound to the upper bound itself. Parameters ---------- lower: float, optional Lower","expr: str, optional SQL expression. by: list, optional vColumns used in the partition.","optional If set to True, draw an Area Plot. step: bool, optional If","limits of the current axes. ax: Matplotlib axes object, optional The axes to","conducting # data science projects on data stored in Vertica, taking advantage Vertica’s","] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev,","colors[idx % len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel,","from the vDataFrame. Dropping a vColumn means simply not selecting it in the","object, optional The axes to plot on. **style_kwds Any optional parameter to pass","parameter to False, the function's performance can drastically decrease. Returns ------- float/str median","------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature by","plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel.","approx: bool, optional If set to True, the approximate quantile is returned. By","result = executeSQL( query, title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\", )","valid if the vColumns are numerical. Optimized h will be computed if the","vDataFrame.astype : Converts the vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])])","\"int\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool","self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \"\"\"","x^2 + 2 use \"POWER({}, 2) + 2\". copy_name: str, optional If not","vColumn category is date. \"\"\" return self.category() in (\"float\", \"int\") # ---# def",": Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn.","vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075","only if the parameter 'by' is empty\\nIf you want to normalize by grouping","history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns","the input vColumns using the input method. Parameters ---------- method: str, optional Method","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS","\\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\ #","only categorical aggregations during the computation. cat_stats : Computes statistics of a numerical",") else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\",","supports the # entire data science life cycle, uses a ‘pipeline’ mechanism to","If the vColumn type is date like (date, datetime ...), the parameter 'x'","result[i - 1], result[i] ) trans += \" ELSE NULL END)\" trans =","(None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of the","bar. If empty, an optimized h will be computed. ax: Matplotlib axes object,","the vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations","absolute value of the record is greater than the threshold it will be","Parameters ---------- func: list List of the different aggregation. aad : average absolute","numcol, [str]), ] ) method = method.lower() assert (method != \"cat_stats\") or (numcol),","depending on the input method. Parameters ---------- method: str, optional The describe method.","in each of the vColumn records by an input value. vDataFrame[].str_slice : Slices","else: final_transformation = [ ( \"({} - {}) / {}({} - {})\".format( \"{}\",","the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if","THEN argv[2 * i + 1] ... ELSE argv[n] END Returns ------- vDataFrame","------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","n == 1: try: result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {}","donut chart of the vColumn based on an aggregation. \"\"\" if isinstance(pie_type, str):","op1, close_l = \"<\", \"]\" if labels: label = labels[idx] else: label =","dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns -------","{})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem'","# ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the","{}, {}({}) FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] )","WOE & IV of {} (response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title)","Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR","the vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate :","int))) else \"\" ) upper_when = ( \"WHEN {} > {} THEN {}",") try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except:","+ {}{}) || ']'\".format( \"{}\", h, h, \"{}\", h, h, h, floor_end ),","self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\"Computing","method: dict, optional Method to use to impute the missing values. auto :","= executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", ) result =","def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input type.","\"text\") else: trans = (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method","bool, optional Uses numbers as suffix instead of the vColumns categories. Returns -------","val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records are in the","float]), (\"dropna\", dropna, [bool])]) topk = \"\" if (k < 1) else \"LIMIT","ctype = \"float\", \"float\" elif method == \"0ifnull\": category, ctype = \"int\", \"bool\"","= \"\", prefix_sep: str = \"_\", drop_first: bool = True, use_numbers_as_suffix: bool =","list = [], include_lowest: bool = True, right: bool = True, ): \"\"\"","\"\", area: bool = False, step: bool = False, ax=None, **style_kwds, ): \"\"\"","self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", ) top =","Parameters ---------- method: str, optional Method to use to compute the optimal h.","[\"date\", \"float\"]: warning_message = ( \"label_encode is only available for categorical variables.\" )","conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label","columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = (","if the vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn","self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass","will be picked or computed) h: float, optional Interval width of the bar.","= round(h, 4) elif h > 0.000001: h = round(h, 6) if self.category()","h: float = 0, max_cardinality: int = 8, cat_priority: list = [], ax=None,","float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input","gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in","use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins,","YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn","ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the","# /\\ \\ / / /\\ ___\\ /\\ __ \\ /\\ \\ /\\","density : Percentage of the distribution. mean : Average of the vColumn 'of'.","parent, alias, [elem for elem in transformations], ) self.catalog = { \"cov\": {},","using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model","\"text\", ) else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans =","100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {}","set to True, the approximate cardinality is returned. By setting this parameter to","100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to the vColumn {} using","max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor =","* int(nbins): nth_elems += [str(total)] total += nb where = \"WHERE _verticapy_row_nb_ IN","{} THEN {} WHEN {} > {} THEN {} ELSE {} END)\".format( \"{}\",","the parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns -------","Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","= self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h,","--------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns ------- int vColumn","representing the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will","(result) else result[0][0] if not (dropna): n = \"\" if (n == 1)","is only valid if the vColumns are numerical. Optimized h will be computed","number cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent","cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential function","isinstance(index, int): cast = \"::float\" if self.category() == \"float\" else \"\" if index","\", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"]","self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func 'x","return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if self.category() == \"float\" else","the logic to the data. # # # Modules # # Standard Python","executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False,","regular width bins. smart : Uses the Random Forest on a response column","), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__()","self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY","self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap","See Also -------- vDataFrame[].tail : Returns the a part of the vColumn. \"\"\"","tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be","title=\"Computing the top{} categories of {}.\".format( k if k > 0 else \"\",","bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by","---------- n: int Number of digits to keep after the comma. Returns -------","\"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\",","{}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha ==","import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) )","new_category: str, optional The name of the merging category when using the 'topk'","vColumn. The function variable must be composed of two flower brackets {}. For","[name] conj = \"s were \" if len(all_new_features) > 1 else \" was","# ---# def fill_outliers( self, method: str = \"winsorize\", threshold: float = 4.0,","OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM","for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in","{\"n_estimators\": 20, \"max_depth\": 10} to train a Random Forest with 20 trees and","based on an aggregation. Parameters ---------- method: str, optional The method to use","cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot","self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {} AS","check_types([(\"val\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self):","+= [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def","\"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum()","Also -------- vDataFrame[].head : Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit,","self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs): from","prefix: str = \"\", prefix_sep: str = \"_\", drop_first: bool = True, use_numbers_as_suffix:","new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50):","mode(self, dropna: bool = False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the","{}. For example to apply the function: x -> x^2 + 2 use","AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x","DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field:","{}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] !=","{} WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(),","the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1","bar( self, method: str = \"density\", of: str = \"\", max_cardinality: int =","The vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns -------","assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or equals to","= [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\"color\":","-------- vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum :","one of the following: date / int / float / text / binary","to 'cat_stats'. Returns ------- tablesample An object containing the result. For more information,","\"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else:","prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\")","return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # #","vColumn 'of'. sum : Sum of the vColumn 'of'. q% : q Quantile","ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE","str vColumn alias. transformations: list, optional List of the different transformations. Each transformation","return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \"\"\" ---------------------------------------------------------------------------","lp, rp = \"(\", \")\" else: lp, rp = \"\", \"\" for category","---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for",") else: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \",","by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [","), print_time_sql=False, ) except: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format(","trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans = (\"{} || ''\",","to True, the approximate quantile is returned. By setting this parameter to False,","must be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat","---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains","interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute","+ 1) and (method != \"numerical\")) or not (is_numeric) or (method == \"categorical\")","vColumn and creating a copy with the specified name. \\u26A0 Warning : SQL","Also -------- vDataFrame[].ctype : Returns the vColumn database type. \"\"\" return self.transformations[-1][2] #","(No h will be picked or computed) ax: Matplotlib axes object, optional The","check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column","computed if the parameter is empty or invalid. max_cardinality: int, optional Maximum number","ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result","AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS","method == \"mean\": query = \"WITH vdf_table AS (SELECT * FROM {}) (SELECT","elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\":","part of the vColumn (delimited by an offset and a limit). Parameters ----------","USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =","parameter. alpha: float, optional Number representing the outliers threshold. Values lesser than quantile(alpha)","when using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna :","_| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________","down to the next whole number ln : natural logarithm log : logarithm","def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis","work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\": if n","= \"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def","--------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str,","self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax,","data science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation","float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold: result","input vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval :","'{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN \" + \" WHEN \".join(conditions)","k >= 2, ParameterError( \"Parameter 'k' must be greater or equals to 2","as upper bound quantile(1-alpha) if 'use_threshold' is set to False else the lower","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0]","self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied to the vColumn {}\\n{} feature{}created:","+= [column] if not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] =","if the response is numerical (except ints and bools), a RF Classifier otherwise.",": Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 *",": Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with","dropna, [bool])]) topk = \"\" if (k < 1) else \"LIMIT {}\".format(k) dropna","\\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/","vColumn using the input list. Parameters ---------- breaks: list List of values used","raised to the power of another number round : rounds a value to","\\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\ # \\ \\",": Applies a function to the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks,","using the input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])])",": Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna,","elif h > 0.0001: h = round(h, 4) elif h > 0.000001: h","= sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws","kwargs[\"legend\"] = True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return","= None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / (","each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in","from the vColumn (only if the vColumn type is date like). The vColumn","str The field to extract. It must be one of the following: CENTURY","is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during the","__ \\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\","Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self):","dropna = \" WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else \"\" query","built-in analytics and machine learning features. It supports the # entire data science","= 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%',","optional If set to True, the information will be stored in the vDataFrame","self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0: warning_message = \"Can not normalize","must have a numerical value\" ) lower_when = ( \"WHEN {} < {}","cat = [], self.distinct() if len(cat) == 1: lp, rp = \"(\", \")\"","vColumn. If this parameter is equal to 0, an optimised interval will be","NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\".format( self.alias, query, )","include_lowest: op1, close_l = \"<=\", \"[\" elif idx == 0: op1, close_l =","Regular expression to replace. value: str, optional New value. Returns ------- vDataFrame self.parent","+ \" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn","a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The","/ {}) * {} + {}{}) || ']'\".format( \"{}\", h, h, \"{}\", h,","MIN and the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return","] ) donut = True if pie_type == \"donut\" else False rose =","\".join([quote_ident(column) for column in by]) ) if (by) else \"\" ) order_by_ts =","up to the next whole number cos : trigonometric cosine cosh : hyperbolic","is numerical, False otherwise. Returns ------- bool True if the vColumn is numerical.","\"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]),","'03-11-1993' will filter the data when 'ts' is greater than November 1993 the","method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method","-------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\" import sys total =","optional Cardinality threshold to use to determine if the vColumn will be considered","computed. h: float, optional Interval width of the bar. If empty, an optimized","Matplotlib axes object \"\"\" columns = [self.alias] check = True if len(args) >",": value down to the next whole number ln : natural logarithm log","or numerical. by: str, optional vColumn to use to partition the TS. start_date:","name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") )","1], result[i], result[i - 1], result[i] ) trans += \" ELSE NULL END)\"","= self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count()","Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y =","return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def","utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of the vColumn.","str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} )","p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent # ---# def fillna( self, val=None,","FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the vColumn","outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0","\"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result =","2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) /","the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) #","expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression","---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---#","threshold: float, optional Uses the Gaussian distribution to identify outliers. After normalizing the","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float","'[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i - 1], result[i] ) trans","distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)):","vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate():","Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float A float","else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn",") ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias of","vDataFrame has been transformed multiple times, so it's better practice to use this","input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply(","self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}'","of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable",") new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, )","max_cardinality ) if distinct_count > max_cardinality: query += ( \"UNION ALL (SELECT 'Others',","index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if self.category()","or isinstance(val, float): category, ctype = \"float\", \"float\" elif method == \"0ifnull\": category,","elements. density : Percentage of the distribution. mean : Average of the vColumn","({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product","PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5)","alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of","self.alias, dtype ) ) return self.parent except Exception as e: raise ConversionError( \"{}\\nThe","in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format(","int, optional Number of elements to display. offset: int, optional Number of elements","[ ( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else","{}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER","one vColumn can only have one parent. catalog: dict, optional Catalog where each","COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean,","(\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method ==","the absolute value of the record is greater than the threshold it will","Maximum number of the vColumn distinct elements to be used as categorical (No","{} as Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding","self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ) else: final_transformation =","self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \"\"\" ---------------------------------------------------------------------------","AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4}","median). It can also be a cutomized aggregation (ex: AVG(column1) + 5). of:","If set to True, the approximate median is returned. By setting this parameter","area: bool, optional If set to True, draw an Area Plot. step: bool,","result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{},","1) return best_h # ---# def nunique(self, approx: bool = True): \"\"\" ---------------------------------------------------------------------------",") result = executeSQL( query, title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\",","DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in","= '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query +","if mad != 0: if return_trans: return \"({} - {}) / ({})\".format(self.alias, med,","func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {}","one parent. catalog: dict, optional Catalog where each key corresponds to an aggregation.","[] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\"color\": colors[idx","result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER","represent the number of seconds, otherwise it will represent a number. Returns -------","= kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a","min) / (max - min) by: list, optional vColumns used in the partition.","/ _ __|_. _ _ |_) # \\/ (/_| | |(_(_|| \\/ #","def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input element.","assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y)","({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) ) query = \"SELECT {} FROM","vColumns, cast the other types to varchar. same_freq : Computes bins with the","offers beautiful graphical options. # # VerticaPy aims to do all of the","equals to 2 in case of discretization using the method 'same_freq'\" ) count","* 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q: tuple","(\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of)","int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of","y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be binary","--------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func: list List","def density( self, by: str = \"\", bandwidth: float = 1.0, kernel: str","add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return parent","between 0 and 1 that represents the quantile. For example: 0.25 represents Q1.",") values = { \"index\": [item[0] for item in result], \"count\": [int(item[1]) for","self.parent # ---# def median( self, approx: bool = True, ): \"\"\" ---------------------------------------------------------------------------","regular expression matches in each of the vColumn record by an input value.","the equal frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0] for elem in","---# def describe( self, method: str = \"auto\", max_cardinality: int = 6, numcol:","greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also --------","numcol: str, optional Numerical vColumn to use when the parameter method is set","assert (lower != None) or (upper != None), ParameterError( \"At least 'lower' or","aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list","(\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h,","method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index","query, nth_elems = nb, [], [] while total < int(float(count / int(nbins))) *","None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query","function variable must be composed of two flower brackets {}. For example to","[ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\",","else \"NULL\", elem[1] if elem[1] != None else \"NULL\", ) for elem in","item[0] for item in executeSQL( query=query, title=\"Computing the average of the {}'s lower","= True if pie_type == \"donut\" else False rose = True if pie_type","vColumn. The aggregations used are the median and two input quantiles. Parameters ----------","be picked or computed) ax: Matplotlib axes object, optional The axes to plot","self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\")","from collections.abc import Iterable from typing import Union # VerticaPy Modules import verticapy","mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN","of \" \"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \"","the vColumn most occurent elements. \"\"\" if \"agg\" not in kwargs: query =","occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","\\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class","if total > 1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj))","will be picked or computed) nbins: int, optional Number of bins. If empty,","hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit:","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot","else: lp, rp = \"\", \"\" for category in cat: tmp_query = \"\"\"SELECT","= ( \"WHEN {} < {} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower,","** (1.0 / 3.0), 1e-99) if method.lower() == \"sturges\": best_h = sturges elif","{} || ';' || (FLOOR({} / {}) * {} + {}{}) || ']'\".format(","\"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as percents.","[by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \"method\", method, [","on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\",","ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"]","def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of","tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn.","\"LIMIT {}\".format(k) dropna = \" WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else","vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" ---------------------------------------------------------------------------","n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters","of {} (response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"]","offset = max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample(","\"\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None,","to the input vColumns. vDataFrame.applymap : Applies a function to all the vColumns.","= [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a","k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)),","Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n","number of distinct elements for vColumns 1 and 2 to be used as","True if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True","--------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned by the",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self,","It must be one of the following: CENTURY / DAY / DECADE /","the median). It can also be a cutomized aggregation (ex: AVG(column1) + 5).","= 0): \"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an","pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart","{}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {},","method=\"fetchall\", ) top = None if not (result) else result[0][0] if not (dropna):","how often they occur, and other statistical information. Parameters ---------- k: int, optional","item in sublist] # ---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the","the learning and scoring phases. xlim: tuple, optional Set the x limits of","\"[Add Copy]: A copy of the vColumn {} named {} was added to","(isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int,","method not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by if method","# ---# def get_dummies( self, prefix: str = \"\", prefix_sep: str = \"_\",","example, if n = 1 then this method will return the mode of","start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a","The function variable must be composed of two flower brackets {}. For example","else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied to","of the vColumn. vDataFrame[].extract : Extracts the regular expression in each record of","where each key corresponds to an aggregation. vColumns will memorize the already computed","_ |_) # \\/ (/_| | |(_(_|| \\/ # / # VerticaPy is","q% : q quantile (ex: 50% for the median) prod : product range","ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds,","result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second',","categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also","(\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf","Python Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable from","\"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\":","upper and lower outliers by their respective average. null : Replaces the outliers","Rose chart. It can also be a cutomized aggregation (ex: AVG(column1) + 5).","a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def","Aggregates the vColumn using the input functions. Parameters ---------- func: list List of","---# def mode(self, dropna: bool = False, n: int = 1): \"\"\" ---------------------------------------------------------------------------","sqrt : arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent","of digits to keep after the comma. Returns ------- vDataFrame self.parent See Also","vDataFrame.bar : Draws the Bar Chart of the input vColumns based on an","vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a user","vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of,","# ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns","can be seen as one column of that relation. vColumns simplify several processes","For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new","> 0.000001: h = round(h, 6) if self.category() == \"int\": h = int(max(math.floor(h),","{}\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \"SELECT {} FROM {}","Parameters ---------- n: int Number of digits to keep after the comma. Returns","by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns","WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC","= \"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE",") if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias]","_verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias,","method.lower() == \"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h =","max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if","for the median) prod : product range : difference between the max and","# ---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return","extract. It must be one of the following: CENTURY / DAY / DECADE","self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a time series","result = [distinct_count] + result index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\",","The vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval width","Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also --------","\"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM {}\".format( trans,","check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def","method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem in order_by]","), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans:","the vDataFrame has been transformed multiple times, so it's better practice to use","Python object which that stores all user transformations. If the vDataFrame represents the","( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name","\"agg\" not in kwargs: query = \"SELECT {} AS {} FROM {} WHERE","vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the other types","by transforming the values lesser than the lower bound to the lower bound","FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the","ceil : value up to the next whole number cos : trigonometric cosine","\"\" query, cat = [], self.distinct() if len(cat) == 1: lp, rp =","'of'. q% : q Quantile of the vColumn 'of' (ex: 50% to get",">= 2, ParameterError( \"Parameter 'nbins' must be greater or equals to 2 in","[int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import","warning_message = \"The vColumn {} has no mode (only missing values).\\nNothing was filled.\".format(","\"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def","try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 *","abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns","converted to {}\".format( e, self.alias, dtype ) ) # ---# def avg(self): \"\"\"","--------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if the vColumn","st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by: str = \"\",","use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns categories. Returns","input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns","): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule.","been transformed multiple times, so it's better practice to use this method when","a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name","\"int\"), TypeError( \"The column 'numcol' must be numerical\" ) cast = \"::int\" if","self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","[bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n =","optional The bandwidth of the kernel. kernel: str, optional The method used for","optional Number of most occurent elements to return. dropna: bool, optional If set","not (dropna): n = \"\" if (n == 1) else str(int(n)) if isinstance(top,","QueryError( \"{}\\nError when applying the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\",","(PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The","'{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), )","slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part","grouping by elements, please use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self","= '03-11-1993' will filter the data when 'ts' is lesser than November 1993","cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of","+ sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total #","vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n","): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ----------","def head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head of the","has been transformed multiple times, so it's better practice to use this method","True if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True","if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if","method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold,","Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])])","{} can not be converted to {}\".format( e, self.alias, dtype ) ) #",": conditional value at risk dtype : vColumn type iqr : interquartile range","Quantile of the vColumn 'of' (ex: 50% to get the median). It can","Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies :","k > 0 else \"\", self.alias ), method=\"fetchall\", ) values = { \"index\":","vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new","Parameters ---------- val: list List of the different records. For example, to check","THEN argv[2 * i + 1] ... END odd : CASE ... WHEN","bool, optional If set to True, the approximate quantile is returned. By setting","max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func)","catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem","2, ParameterError( \"Parameter 'k' must be greater or equals to 2 in case","categorical (No h will be picked or computed) nbins: int, optional Number of",") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines","and it returns the new vDataFrame of the search. Parameters ---------- val: list","= \"<=\", \"<\", \"[\", \"[\" if idx == 0 and include_lowest: op1, close_l","/ {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha","elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv:","{} AND {}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" )","(\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method == \"median\") else \"AVG\" if","n): trans += \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\",","phases. xlim: tuple, optional Set the x limits of the current axes. ax:","---# def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest","force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias)",") else: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \",","vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") #","of {}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result for item in","\"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method = method.lower()","will be created using the input Name. Returns ------- vDataFrame self.parent See Also","\"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else:","the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum","spatial / uuid / undefined Returns ------- str vColumn category. See Also --------","--------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the lower bound","type is date like (date, datetime ...), the parameter 'x' will represent the","[ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]),","for the specific language governing permissions and # limitations under the License. #","--------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0]","{} using the following mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---#","def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns","Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \"\"\" pre_comp =","Returns True if the vColumn is boolean, False otherwise. Returns ------- bool True","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod =","mad). (x - median) / (1.4826 * mad) minmax : Normalization using the",") values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and","aggregations used are the median and two input quantiles. Parameters ---------- ts: str","------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","!= \"robust_zscore\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor:","use to transform the vColumn. abs : absolute value acos : trigonometric inverse","max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name:","\"It can be the result of using previously the method on the vColumn","else: self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem] =","product # ---# def quantile(self, x: float, approx: bool = True): \"\"\" ---------------------------------------------------------------------------","A copy of the vColumn {} named {} was added to the vDataFrame.\".format(","assert response_cat == [0, 1], TypeError( \"vColumn {} must be binary to use",") if (by) else \"\" ) order_by_ts = \", \".join([quote_ident(column) + desc for","---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average","elements to skip. Returns ------- tablesample An object containing the result. For more","to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1],","name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins' must","[ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int,","aggregations could work if it is part of the DB version you are","result if elem[1] != None ] ), ) stddev = \"DECODE({}, {}, NULL)\".format(","to the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]),","0, nbins: int = -1, k: int = 6, new_category: str = \"Others\",","model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params()","function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} *","This parameter is used for testing purpose. Returns ------- vDataFrame self.parent See Also","\"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","the tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int,","\"<=\", \"[\" elif idx == 0: op1, close_l = \"<\", \"]\" if labels:","most occurent elements, how often they occur, and other statistical information. Parameters ----------","Encodes the vColumn using the mean encoding of a response. \"\"\" check_types( [","Returns the k most occurent elements, how often they occur, and other statistical","self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail #","if it is used to compute other vColumns. Parameters ---------- add_history: bool, optional","self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN {} > {} THEN","\" if total > 1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total,","< 0: offset = max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail","\"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation. Parameters","\"Others\", RFmodel_params: dict = {}, response: str = \"\", return_enum_trans: bool = False,","list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth,","the vColumn using the mean encoding of a response. \"\"\" if self.category() in","vColumn is boolean, False otherwise. Returns ------- bool True if the vColumn is","self.category() == \"float\" else \"\" if index < 0: index += self.parent.shape()[0] query","query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0] for","the vColumn using the average of the response partitioned by the different vColumn","# # __ __ ______ ______ __ __ __ __ __ __ __","max_cardinality, [list]), (\"h\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by","= [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = (","/ # |______ / / / # |____/ / / # _____________ /","self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to","[str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\",","for item in result], \"percent\": [float(round(item[2], 3)) for item in result], } return","the first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional","---------- threshold: float, optional Uses the Gaussian distribution to identify outliers. After normalizing","query = \"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({})","the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to pass","the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :","1], [1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"', \"\")","self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name)","values = { \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result,","can make the vDataFrame \"heavier\" if it is used to compute other vColumns.","[str]), (\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT {} AS apply_test_feature","(\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ),","ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB","/ TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also --------","\"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr,","in kwargs: query = \"SELECT {} AS {} FROM {} WHERE {} IS","else \"\", stddev ) else: final_transformation = [ ( \"({} - {}) /","'{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The vColumn must be numerical for","computed) h: float, optional Interval width of the bar. If empty, an optimized","} return tablesample(values) # ---# def value_counts(self, k: int = 30): \"\"\" ---------------------------------------------------------------------------","float, optional Interval width of the bar. If empty, an optimized h will","elem in result if elem[1] != None ] ), ) cmax = \"DECODE({},","method: str = \"auto\", expr: str = \"\", by: list = [], order_by:","elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method == \"median\")","(\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---#","ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {}","the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.","plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames","> 0: warning_message = \"The method 'robust_zscore' is available only if the parameter","[item[0] for item in result], \"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2],","'prefix_sep'), you'll be able to solve this \" \"issue.\" ) for k in","category is date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\"","vDataFrame[].dropna : Drops the vColumn missing values. \"\"\" if isinstance(by, str): by =","NOT NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n )","in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"],","alias: str, transformations: list = [], parent=None, catalog: dict = {} ): self.parent,","float = 0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds,","optional If set to True, the Median will be drawn. ax: Matplotlib axes","\"auto\"])] ) method = method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\")","h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the","None): return pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must be greater or","agg = aggregate # ---# def apply(self, func: str, copy_name: str = \"\"):","optional If set to True, the approximate cardinality is returned. By setting this","final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])","bool, optional Uses the threshold instead of the 'alpha' parameter. alpha: float, optional","Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\" import sys total","the input vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval","the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","each key corresponds to an aggregation. vColumns will memorize the already computed aggregations","popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use","of its affiliates. # Licensed under the Apache License, Version 2.0 (the \"License\");","use to evaluate the approximate density function. Increasing this parameter will increase the","\"density\", of: str = \"\", max_cardinality: int = 6, h: float = 0,","rose = True if pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of) of","Parameters ---------- approx: bool, optional If set to True, the approximate cardinality is","not (\"figsize\" in kwargs): kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---#","with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List","bool = True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in","vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} <","datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]),","= [], self.distinct() if len(cat) == 1: lp, rp = \"(\", \")\" else:","than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent","{} was deleted from the vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers(","See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in each","Encoding was applied to the vColumn {} using the following mapping:{}\".format( self.alias, text_info","--------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of digits after","self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"',","Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]),","to consider when drawing the box plot. The other categories will be filtered.","fun, \"{}\", \", \".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY","in result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__()","For example, time = '03-11-1993' will filter the data when 'ts' is greater","\"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx:","self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() ==","Parameters ---------- x: float If the vColumn type is date like (date, datetime","vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\")","in each of the vColumn records. vDataFrame[].extract : Extracts the regular expression in","VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n","casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]:","\"\"\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts: str","def numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar","\"\"\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns -------","!\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try: result","trees and a maximum depth of 10. response: str, optional Response vColumn when","DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1) query","a new category : 'Others'. cat_priority: list, optional List of the different categories","\"]\" if labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [","the length of parameter 'labels' + 1 or parameter 'labels' must be empty.\"","dict = {}, response: str = \"\", return_enum_trans: bool = False, ): \"\"\"","be generated. include_lowest: bool, optional If set to True, the lowest element of","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0]","represents the entire relation, a vColumn can be seen as one column of","+ result, } if ((is_date) and not (method == \"categorical\")) or ( method","all_new_features += [name] conj = \"s were \" if len(all_new_features) > 1 else","only works on numerical / date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError(","vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies","ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by: str =","donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by:",": Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode","of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR /","sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem)","= {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if","columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \"\"\"","FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\".format(","result + [self.max()] elif method == \"topk\": assert k >= 2, ParameterError( \"Parameter","median : median. mode : mode (most occurent element). 0ifnull : 0 when",") query = \"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN","\"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\":","AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4}","Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y","{} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {}","std robust_zscore : Normalization using the Robust Z-Score (median and mad). (x -","vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is","optional Number of elements to display. offset: int, optional Number of elements to","\"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if","missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using","get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column)","sine sinh : hyperbolic sine sqrt : arithmetic square root tan : trigonometric","only have one parent. catalog: dict, optional Catalog where each key corresponds to","vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval : Evaluates","input 'quantile'. Parameters ---------- x: float A float between 0 and 1 that","and not (method == \"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index,","if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if","expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter(","\"\") ) ) # ---# def apply_fun(self, func: str, x: float = 2):","str, by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str,","least one element to use to order the data\" ) desc = \"\"","return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad !=","records. For example, to check if Badr and Fouad are in the vColumn.","return self.parent # ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories","'smart'. A RF Regressor will be trained if the response is numerical (except","to plot on. **style_kwds Any optional parameter to pass to the Matplotlib functions.","value. winsorize : Clips the vColumn using as lower bound quantile(alpha) and as","False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot of the vColumn.","\"mode\" total = self.count() if (method == \"mode\") and (val == None): val","cat_stats : Computes statistics of a numerical column for each vColumn category. In","{}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else: new_column","of discretization using the method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can","kth most occurent element density unique : cardinality (count distinct) var : variance","bfill : Back Propagation of the next element (Constant Interpolation). ffill : Propagation","= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e:","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an","\".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun,","--------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks: list List","meaning global outlier). \"\"\" if isinstance(method, str): method = method.lower() check_types( [ (\"method\",","otherwise. Returns ------- bool True if the vColumn category is date. See Also","= [], include_lowest: bool = True, right: bool = True, ): \"\"\" ---------------------------------------------------------------------------","{}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\".format( self.alias,","vDataFrame.donut : Draws the donut chart of the vColumn based on an aggregation.","self.isnum() or self.isdate(), ParameterError( \"numh is only available on type numeric|date\" ) if","COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias,","catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2,","arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float,","specified number of decimal places sign : arithmetic sign sin : trigonometric sine","+ desc for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER","str = \"winsorize\", threshold: float = 4.0, use_threshold: bool = True, alpha: float","vColumn to use to partition the data. method: str, optional The method to","vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the","to identify outliers. After normalizing the data (Z-Score), if the absolute value of","of the vColumn based on an aggregation. Parameters ---------- method: str, optional The","number of decimal places sign : arithmetic sign sin : trigonometric sine sinh","will filter the data when 'ts' is greater than November 1993 the 3rd.","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] #","label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}'","50): try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {},","[list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\" ---------------------------------------------------------------------------","an aggregation. Parameters ---------- by: str, optional vColumn to use to partition the","total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem","elements in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT *","{}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, )","setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the","\"\", max_cardinality: int = 6, nbins: int = 0, h: float = 0,","the discretization. topk : Keeps the topk most frequent categories and merge the","return tablesample(values) # ---# def discretize( self, method: str = \"auto\", h: float","must be a list of at least one element to use to order","( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor )","--------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See Also --------","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the","slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the","warning_message = \"Can not normalize {} using the MIN and the MAX. MAX","query = \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile","Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns","the specific language governing permissions and # limitations under the License. # #","the vDataFrame \"heavier\" if it is used to compute other vColumns. Parameters ----------","executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item for","of the different records. For example, to check if Badr and Fouad are","self.alias, table ) result = executeSQL( query, title=\"Different aggregations to compute the optimal","not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the","plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes","result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---#","Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize :","AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP","lower: float, optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame","{}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality","[int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} -","if not (\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if","\"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\",","\"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\", \"avg\", \"median\"):","[ item[0] for item in executeSQL( query=query, title=\"Computing the average of the {}'s","str = \"\", by: list = [], order_by: list = [], ): \"\"\"","= \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0,","] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \",","Returns the vColumn memory usage. Returns ------- float vColumn memory usage (byte) See","1 that represents the quantile. For example: 0.25 represents Q1. approx: bool, optional","\\ \\/\\ \\ \\ \\ \\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\","regular expression in each record of the vColumn. vDataFrame[].extract : Extracts the regular","vColumn using 'mad' (median absolute deviation). Returns ------- float mad See Also --------","greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also --------","---------- by: str, optional vColumn to use to partition the data. h: float,","distributed under the License is distributed on an \"AS IS\" BASIS, # WITHOUT","element. Parameters ---------- dropna: bool, optional If set to True, NULL values will","date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the","sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] )","\" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied to the vColumn {}\\n{}","the data when 'ts' is greater than November 1993 the 3rd. plot_median: bool,","\"0ifnull\"]: max_floor = 0 all_partition = by if method in [\"ffill\", \"pad\", \"bfill\",","\"(CASE \" for i in range(1, n): trans += \"WHEN {} BETWEEN {}","/ ( 1.4826 * sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] = (sauv[elem]","object. Parameters ---------- *args / **kwargs Any optional parameter to pass to the","frequent categories and merge the other into one unique category. h: float, optional","Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","int/tuple, optional Maximum number of distinct elements for vColumns 1 and 2 to","alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the","is 'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if","data (Z-Score), if the absolute value of the record is greater than the","cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ),","less frequent elements will be gathered together to create a new category :","to True, NULL values will not be considered during the computation. Returns -------","the following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn. One","max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] ) method = method.lower() assert (method","For example, if n = 1 then this method will return the mode","date, optional Input Start Date. For example, time = '03-11-1993' will filter the","= executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return [item","!= \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None): return pre_comp assert n","vDataFrame[].tail : Returns the tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]),","method ) ) else: raise TypeError(\"The vColumn must be numerical for Normalization\") return","`\\ / / # | \\/ / / / # |______ / /","Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also --------","---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__()","!= \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias),",": Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode","Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])])","the vColumn (only if the vColumn type is date like). The vColumn will","vColumn memory usage. Returns ------- float vColumn memory usage (byte) See Also --------",">= 2, ParameterError( \"Parameter 'k' must be greater or equals to 2 in","(Z-Score), if the absolute value of the record is greater than the threshold","the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns = [","by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count <","self.category() in (\"float\", \"int\") # ---# def iv_woe(self, y: str, nbins: int =","= int(float(count / int(nbins))) assert nb != 0, Exception( \"Not enough values to","{} AS {} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional","boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\" ---------------------------------------------------------------------------","self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def","it will represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply","name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not","to use to fill the vColumn outliers. mean : Replaces the upper and","use to compute the optimal h. auto : Combination of Freedman Diaconis and","from verticapy.errors import * ## # # __ __ ______ ______ __ __","self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing","of at least one element to use to order the data\" ) desc","\\u26A0 Warning : SQL code generation will be slower if the vDataFrame has","index mad : median absolute deviation max : maximum mean : average median",") donut = True if pie_type == \"donut\" else False rose = True","time of the learning and scoring phases. xlim: tuple, optional Set the x","function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return","\"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the","elements in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional","of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\")","vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\"))","|. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # / __","(count distinct) var : variance Other aggregations could work if it is part","self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self, func: str, x: float =","custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param =","[int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha =","\"\" if index < 0: index += self.parent.shape()[0] query = \"SELECT {}{} FROM","LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = (","import verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import","variable must be composed of two flower brackets {}. For example to apply","of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality,","split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {})","alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if","elem in result if elem[1] != None ] ), ) stddev = \"DECODE({},","tangent x: int/float, optional If the function has two arguments (example, power or","Applies a function to the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return","= KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(),","vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int =","See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k,","Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with","method: str, optional Method to use to fill the vColumn outliers. mean :","), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: cmax,",": Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return","--------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns ------- vDataFrame","optional Number of elements to skip. Returns ------- tablesample An object containing the","[1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"', \"\") +","0, ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\", x)) #","(self.category() == \"int\") else \"\" if (h > 1) or (self.category() == \"float\"):","NULL values will not be considered during the computation. Returns ------- tablesample An","vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn is numerical.","copy with the specified name. \\u26A0 Warning : SQL code generation will be","specific records are in the vColumn and it returns the new vDataFrame of","[str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError(","/ 3.0), 1e-99) if method.lower() == \"sturges\": best_h = sturges elif method.lower() in","# _ # \\ / _ __|_. _ _ |_) # \\/ (/_|","parameter 'new_name', you'll be able to solve this issue.\" ) self.add_copy(new_name) parent =","and Fouad are in the vColumn. You can write the following list: [\"Fouad\",","__ __ __ __ # /\\ \\ / / /\\ ___\\ /\\ __","\"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---#","to compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1","self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality,","utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame","If set to True, the lowest element of the list will be included.","\"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ---------- method:","of the vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]),","in the vColumn. You can write the following list: [\"Fouad\", \"Badr\"] Returns -------","ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date,","= executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias,","def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns","[str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list,","self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv =","will be considered as categorical. numcol: str, optional Numerical vColumn to use when","drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the","atan : trigonometric inverse tangent cbrt : cube root ceil : value up","to the upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper:","An object containing the result. For more information, see utilities.tablesample. See Also --------","False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element.","\" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp","float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","[\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem in order_by] for elem",") upper_when = ( \"WHEN {} > {} THEN {} \".format(\"{}\", upper, upper)","the Equal Frequency discretization\" ) total, query, nth_elems = nb, [], [] while","cotangent exp : exponential function floor : value down to the next whole","instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode","= 1 if drop_first else 0 for k in range(len(distinct_elements) - n): name","({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha,","str = \"\", h: float = 0, max_cardinality: int = 8, cat_priority: list","\\ / # \\/ # _ # \\ / _ __|_. _ _","self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to the","---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False","---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from the","[(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The","... END odd : CASE ... WHEN vColumn = argv[2 * i] THEN","auto : Mean for the numerical and Mode for the categorical vColumns. bfill","Extracts the regular expression in each record of the vColumn. The vColumn will","the method 'same_freq'\" ) count = self.count() nb = int(float(count / int(nbins))) assert","of elements. density : Percentage of the distribution. mean : Average of the","\"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query)","this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was","self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median,","str_replace(self, to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression","{}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---# def","\"''\")) if elem[0] != None else \"NULL\", elem[1] if elem[1] != None else","information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to","self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total)","result[i - 1], result[i], result[i - 1], result[i] ) trans += \" ELSE","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail","KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot(","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std","self elif n == 1: try: result = executeSQL( \"SELECT {}, MIN({}), MAX({})","# # Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc","works on numerical / date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length","\"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {} GROUP BY","\"rose\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0]","True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn.","the absolute value of the record is greater than the threshold, it will","sinh : hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent","self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\".format( self.alias, method","# ---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming","using the mean encoding of a response. \"\"\" import verticapy.stats as st return","Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean : Average.","The vColumn will be transformed. Parameters ---------- field: str The field to extract.","sequentialize # data transformation operations, and offers beautiful graphical options. # # VerticaPy","\"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns -------","median min : minimum mode : most occurent element percent : percent of","mean encoding of a response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message =","check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix,","in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is in","in self.transformations] total = self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor =","return parent # ---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn","above. The idea is simple: instead of moving # data around for processing,","-------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x,","Iterable from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import","count : number of non-missing elements cvar : conditional value at risk dtype","the input method. Parameters ---------- method: str, optional Method to use to fill","--------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter","if not (result) else result[0][0] if not (dropna): n = \"\" if (n","!= \"cat_stats\") or (numcol), ParameterError( \"The parameter 'numcol' must be a vDataFrame column","OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: cmax, cmin =","Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces","index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if index_start","the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes","BY 1\".format( self.alias, y, y, query, ) query = \"SELECT {}, ord, non_events,","Z-Score (avg and std). (x - avg) / std robust_zscore : Normalization using","is in ffill|pad|bfill|backfill then 'order_by' must be a list of at least one","BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result =","elements to display. Returns ------- tablesample An object containing the result. For more","[best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h), 1) return best_h # ---#","0): \"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset","query = \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) /",": Normalization using the Z-Score (avg and std). (x - avg) / std","-------- vDataFrame.filter: Filters the data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT","return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the","= \"\", h: float = 0, max_cardinality: int = 8, cat_priority: list =","object See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based","conditions, column = [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem","self.parent See Also -------- vDataFrame[].apply : Applies a function to the vColumn. \"\"\"","identify outliers. After normalizing the data (Z-Score), if the absolute value of the","the result of using previously the method on the vColumn \" \"or simply","maximum mean : average median : median min : minimum mode : most","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See","(date, datetime, timestamp...) or numerical. by: str, optional vColumn to use to partition","the Gaussian distribution to define the outliers. After normalizing the data (Z-Score), if","prefix_sep: str = \"_\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ):","( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str,","check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\",","---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ----------","be the result of using previously the method on the vColumn \" \"or","store_usage # ---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular","True if len(args) > 0: column = args[0] elif \"column\" in kwargs: column","= [elem for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem]","\"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division by 0 is","children vColumns whereas one vColumn can only have one parent. catalog: dict, optional","{}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\":","nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias:","elif ( ((distinct_count < max_cardinality + 1) and (method != \"numerical\")) or not","self.isdate(), TypeError( \"cut only works on numerical / date-like vColumns.\" ) assert len(breaks)","\"x\"), ) ) return self.parent except Exception as e: raise QueryError( \"{}\\nError when","kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel.","must be numerical for Normalization\") return self.parent # ---# def nsmallest(self, n: int","Parameters ---------- add_history: bool, optional If set to True, the information will be","vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes","the upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float,","= self.parent[by].distinct() for idx, column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]}","== \"float\" else \"\" if index < 0: index += self.parent.shape()[0] query =","can write the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of","self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\"Computing the top{} categories","mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN","True, NULL values will not be considered during the computation. n: int, optional","to the length of parameter 'labels' + 1 or parameter 'labels' must be","{}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias),","numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width.","NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL(","self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The","expr: str = \"\", by: list = [], order_by: list = [], ):","= new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias","the mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent element.","width. Parameters ---------- method: str, optional Method to use to compute the optimal","------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \"\"\"","\"Length of parameter 'breaks' must be greater or equal to 2.\" ) assert","self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True,","occurent element. Parameters ---------- dropna: bool, optional If set to True, NULL values","({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy","approximate density function. Increasing this parameter will increase the precision but will also","function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate #","the box plot of the vColumn. Parameters ---------- by: str, optional vColumn to","= ( parent, alias, [elem for elem in transformations], ) self.catalog = {","\"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str,",") cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct()","plot of the input vColumn based on an aggregation. Parameters ---------- by: str,","expression in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\"","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def","= True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters","(sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except: pass if method","conditions += [ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ]","a specified number of decimal places sign : arithmetic sign sin : trigonometric","+ prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first else 0 for k","(method in (\"ffill\", \"pad\")) else \" DESC\" partition_by = ( \"PARTITION BY {}\".format(","vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func =","== 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna)","[\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of the search. See Also --------","\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \" \"issue.\" )","NULLS) OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method","= self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return","--------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x: float If","str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) /","ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram of","the comma. Parameters ---------- n: int Number of digits to keep after the","as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened",") fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 /","-({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self):","based on an aggregation. Parameters ---------- by: str, optional vColumn to use to","k: int = 6, new_category: str = \"Others\", RFmodel_params: dict = {}, response:","method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {}","list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def",": q quantile (ex: 50% for the median) prod : product range :","used for the discretization (must be > 1) Returns ------- tablesample An object","+= final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,","transformations. \"\"\" # # Special Methods # # ---# def __init__( self, alias:","def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records are","ax Matplotlib axes object \"\"\" columns = [self.alias] check = True if len(args)","MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE /","apply it. This parameter is very useful for testing to be able to","= 0.75) AS Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias,","VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs, MIN({})","= self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines = []","float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot","on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---#",": percent of non-missing elements q% : q quantile (ex: 50% for the","start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area:","= (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem]","[ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {}","CENTURY / DAY / DECADE / DOQ / DOW / DOY / EPOCH","2 in case of discretization using the method 'smart'.\" ) assert response, ParameterError(","vDataFrame.\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self, func: list):","if (elem[1] == None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\",","the mode.\", method=\"fetchall\", ) top = None if not (result) else result[0][0] if","numerical or of type date like. Optimized h will be computed if the",") title = \"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) #","\"<=\", \"<\", \"[\", \"[\" if idx == 0 and include_lowest: op1, close_l =","aggregation. vColumns will memorize the already computed aggregations to gain in performance. The","len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(),","you'll be able to solve this issue.\" ) new_vColumn = vColumn( name, parent=self.parent,","elem[1] != None else \"NULL\", ) for elem in result if elem[1] !=","+= [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias])","\"gaussian\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\"","will be drawn. ax: Matplotlib axes object, optional The axes to plot on.","--------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn. The vColumn","quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See","[int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]), ] ) if","name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters","--------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation. Parameters ----------","to True, the method will return the transformation used instead of the parent","self.alias, \", \".join(by) ), ) if return_trans: return \"({} - {}) / {}({})\".format(","value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self, start: int, step: int): \"\"\"","(\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]),","the merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of","sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try:","filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations","warning_message = \"Can not normalize {} using a Z-Score - The Standard Deviation","bins will be computed. h: float, optional Interval width of the bar. If","return self.parent # ---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","the discretization (must be > 1) Returns ------- tablesample An object containing the","a function to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\"","cmax - cmin == 0: warning_message = \"Can not normalize {} using the","Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame self.parent See","[int, float]), (\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by =","clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser","events FROM ({}) x GROUP BY 1\".format( self.alias, y, y, query, ) query","] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else:","* COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4})","prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] )","vColumn must be numerical for Normalization\") return self.parent # ---# def nsmallest(self, n:","/\\ \"-./ \\ /\\ \"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____","{} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax,","] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0])","'lower' or 'upper' must have a numerical value\" ) lower_when = ( \"WHEN","gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = []","for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) #","\"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN {} > {}","): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values: for i in range(len(values[elem])):","be converted to {}\".format( e, self.alias, dtype ) ) # ---# def avg(self):","an optimised interval will be computed. nbins: int, optional Number of bins used",") expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations =","\"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\":","considered during the computation. n: int, optional Integer corresponding to the offset. For",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness #","transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also","FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({},","vColumn. The vColumn will be transformed. Parameters ---------- start: int Start of the","self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {}","vColumn. \"\"\" check_types( [ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\",","else False rose = True if pie_type == \"rose\" else False if of:","value\" ) lower_when = ( \"WHEN {} < {} THEN {} \".format(\"{}\", lower,","4.0, use_threshold: bool = True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills","(\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut =","part of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist( self, method:","different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {},","'{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self, start:","advanced analytical function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg =","\")\" else: lp, rp = \"\", \"\" for category in cat: tmp_query =","= \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias,","value of the record is greater than the threshold it will be considered","CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events","obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless","float]), (\"offset\", offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0]","parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame","number raised to the power of another number round : rounds a value","threshold, it will be considered as an outlier. use_threshold: bool, optional Uses the","== \"zscore\": if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\",","None: mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE","elif method == \"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype =","int): cast = \"::float\" if self.category() == \"float\" else \"\" if index <",") result = [distinct_count, self.count()] + [item[1] for item in query_result] index =","in result], } return tablesample(values) # ---# def value_counts(self, k: int = 30):","by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot","\" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format(","# ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element to","the numerical and Mode for the categorical vColumns. bfill : Back Propagation of","1 and 2 bars. It is only valid if the vColumns are numerical.","the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes","executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {}","check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else","expression to replace. value: str, optional New value. Returns ------- vDataFrame self.parent See","\\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql):","\"float\", ) ] elif method == \"robust_zscore\": if n > 0: warning_message =","iv FROM ({}) x ORDER BY ord\".format( self.alias, query, ) title = \"Computing","verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] =","# ____________ ______ # / __ `\\ / / # | \\/ /","of the vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn","step: bool, optional If set to True, draw a Step Plot. ax: Matplotlib","FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality","query += ( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\"","element (Constant Interpolation). mean : Average. median : median. mode : mode (most","computed. pie_type: str, optional The type of pie chart. auto : Regular pie","y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS ord, SUM(1 - {})","mean encoding of a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep,","than November 1993 the 3rd. end_date: str / date, optional Input End Date.","= True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series","!= \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()]","colors = gen_colors() if not xlim: xmin = self.min() xmax = self.max() else:","# ---# def boxplot( self, by: str = \"\", h: float = 0,","int])]) assert (lower != None) or (upper != None), ParameterError( \"At least 'lower'","h: float = 0, nbins: int = -1, k: int = 6, new_category:","OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else: new_column =","self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage.","set to True, the method will return the transformation used instead of the","vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self,","[int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold:",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self,","two arguments (example, power or mod), 'x' represents the second argument. Returns -------","including the 2 quantiles used to draw the Plot. start_date: str / date,","topk : Keeps the topk most frequent categories and merge the other into","---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing.","tail = to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\".format(","h will be picked or computed) nbins: int, optional Number of nbins. If","records. The vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns","\"mean\" if (self.isnum() and self.nunique(True) > 6) else \"mode\" total = self.count() if","labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or","vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \"\"\"","idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ),","[self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id =","\"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ---------- n:","= 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)","--------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as percents. Parameters","bool, optional If set to True, the approximate median is returned. By setting","0.0001: h = round(h, 4) elif h > 0.000001: h = round(h, 6)",": Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations,","\"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\": values =","to gain in performance. The catalog will be updated when the parent vDataFrame","( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn","data. method: str, optional The method to use to aggregate the data. count","Normalization using the Robust Z-Score (median and mad). (x - median) / (1.4826","defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality: int, optional","/ # \\_______/ / / # ______ / / # \\ / /","Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int,","new_name) ) return parent # ---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds","(\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn","user transformations. If the vDataFrame represents the entire relation, a vColumn can be","else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]}","i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also","add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame.","Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns","be 'minute' 'hour'... start: bool, optional If set to True, the record will","self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\") if val != None: new_column","'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame","h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str,",": Adds a new vColumn labeled with 0 and 1 (1 meaning global",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg #","vColumn is null, 1 otherwise. expr: str, optional SQL expression. by: list, optional","self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\")","date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return self.ctype().lower()","You may not use this file except in compliance with the License. #","if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema,","verticapy.toolbox import * from verticapy.errors import * ## # # __ __ ______","p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if","1 or parameter 'labels' must be empty.\" ) conditions, column = [], self.alias","trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root tan :","of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the","= (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif method ==","already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll be able to solve","the vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]), (\"of\",","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM",") else: final_transformation = [ ( \"({} - {}) / {}({} - {})\".format(","for each vColumn category. In this case, the parameter 'numcol' must be defined.","float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x: float):","MINUTE / MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR /","[str(count)]) ) query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY","sauv[elem] elif elem == None: self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem]","if pie_type == \"donut\" else False rose = True if pie_type == \"rose\"","setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A","it's better practice to use this method when first preparing your data. Parameters","- median) / (1.4826 * mad) minmax : Normalization using the MinMax (min","\", \".join([\"1\"] + nth_elems + [str(count)]) ) query = \"SELECT {} FROM (SELECT","new category : 'Others'. cat_priority: list, optional List of the different categories to","the following mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self):","[str])]) try: query = \"SELECT {}::{} AS {} FROM {} WHERE {} IS","a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias]","text_info ) ) return self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","the input element from the vColumn. Parameters ---------- x: float If the vColumn","# ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the","optional Method to use to normalize. zscore : Normalization using the Z-Score (avg","= 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit:","offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def isbool(self):","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head :","\"\"\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an aggregation.","label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories","self.alias, dtype ) ) # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","[] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result","**updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"],","in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM","transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also","input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self, x:","WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the","self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using","> 1) k: int, optional The integer k of the 'topk' method. new_category:",": kth most occurent element (ex: top1 for the mode) topk_percent : kth","the vColumn using 'mad' (median absolute deviation). Returns ------- float mad See Also","see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\"","of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool,","{} must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\"","= [ ( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero)","None), ValueError( \"vColumn doesn't allow slicing having steps different than 1.\" ) index_stop","NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype)","item in query_result] index = [\"unique\", \"count\"] + [item[0] for item in query_result]","Function in pure SQL used to transform the vColumn. The function variable must",") for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [","to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self,","if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in","to use for the discretization. topk : Keeps the topk most frequent categories","vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by = [by] check_types( [ (\"method\",","/ / /\\ ___\\ /\\ __ \\ /\\ \\ /\\ \\/\\ \\ /\\","vColumn '{}' was transformed with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\",","VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 ) result","--------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the","( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075,","executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k if k > 0","self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs, MIN({}) AS min,","decimal, warnings, datetime from collections.abc import Iterable from typing import Union # VerticaPy","the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\"","= { \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\":","number of bins will be computed. h: float, optional Interval width of the","= False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of the","str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating","title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0] for elem","self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns","vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1 (1 meaning","\\ \\-./\\ \\ \\ \\ \\-. \\ # \\ \\__| \\ \\_____\\ \\","[\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method =","an input 'quantile'. Parameters ---------- x: float A float between 0 and 1","the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent =","---# def fill_outliers( self, method: str = \"winsorize\", threshold: float = 4.0, use_threshold:","ts: str TS (Time Series) vColumn to use to order the data. The","# (c) Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed","nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot","be computed. nbins: int, optional Number of bins used for the discretization (must","to the parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns","kernel: str = \"gaussian\", nbins: int = 200, xlim: tuple = None, ax=None,","/\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\ # \\ \\ \\'/","str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date:","Dropping a vColumn means simply not selecting it in the final generated SQL","vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame","tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return","str): \"\"\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype:","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The","greater or equals to 2 in case of discretization using the method 'smart'.\"","\"{}\" ) ) elif method == \"mean\": query = \"WITH vdf_table AS (SELECT","on a response column to find the most relevant interval to use for","), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]),","name ) ) return self.parent # ---# def aggregate(self, func: list): \"\"\" ---------------------------------------------------------------------------","count\" \" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER","cat_priority: list, optional List of the different categories to consider when drawing the","in the vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val =","[item for sublist in query_result for item in sublist] # ---# def div(self,","if the vColumn is numerical, False otherwise. Returns ------- bool True if the","else: op1, op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx ==","(\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\",","---------- val: int/float/str, optional Value to use to impute the vColumn. method: dict,","... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when :","= \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) ) query","Evaluates a customized expression. \"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func,","aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute","str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type.","self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {} to normalize.\".format( by[0] ),","Random Forest on a response column to find the most relevant interval to","to False else the lower and upper ZScores. threshold: float, optional Uses the","= ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] =","), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import","val.replace(\"'\", \"''\") if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr:","Encodes the vColumn using a bijection from the different categories to [0, n","splits when 'method' is set to 'smart'. A RF Regressor will be trained","the threshold it will be considered as an outlier. use_threshold: bool, optional Uses","self.alias, y, y, query, ) query = \"SELECT {}, ord, non_events, events, non_events","/ int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 -","to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns -------","3rd. plot_median: bool, optional If set to True, the Median will be drawn.","return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit: str","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail :","in result] elif self.isnum() and method in (\"same_width\", \"auto\"): if not (h) or","self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be binary to use","[\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method == \"auto\": pre_comp","return [item for sublist in query_result for item in sublist] # ---# def","= \"\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] =","the intervals will be closed on the right. Returns ------- vDataFrame self.parent See","vColumn database type. \"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\"","result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"]","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based","on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\": if n ==","self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat:","Replaces the regular expression matches in each of the vColumn record by an","( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in by]) ) if (by)","vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected","{}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {},","self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be numerical\"","Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See Also --------","be able to solve this issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item","dtype ) ) return self.parent except Exception as e: raise ConversionError( \"{}\\nThe vColumn","quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already","index.start if not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start","Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes","encoding. Parameters ---------- argv: object Any amount of expressions. The expression generated will","elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str = \"auto\"):","str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the","include_lowest: bool = True, right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the","optional vColumn to use to partition the data. method: str, optional The method","int Size of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains","= verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name","{}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {},","len(cat) == 1: lp, rp = \"(\", \")\" else: lp, rp = \"\",","[distinct_count] + result index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\",","LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\",","float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {})","AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(),","Union[str, datetime.datetime, datetime.date] = \"\", area: bool = False, step: bool = False,","if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self,","{} was added to the vDataFrame.\".format( self.alias, name ) ) return self.parent #","in range(1, n): trans += \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]'","the regular expression matches in each of the vColumn records by an input","if stddev == 0: warning_message = \"Can not normalize {} using a Z-Score","of the Random Forest model parameters used to compute the best splits when","to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches","|~) _ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # /","another number round : rounds a value to a specified number of decimal","of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins,","by: str, optional vColumn to use to partition the data. bandwidth: float, optional","= float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top # ---# def","= \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit,","of discretization using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = (","'\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \", \"_\") .replace(\"/\",","\"smart\" ): n = len(result) trans = \"(CASE \" for i in range(1,","= self.aggregate([\"count\", \"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method ==",": Computes the number of matches for the regular expression in each record","raise # ---# def describe( self, method: str = \"auto\", max_cardinality: int =","\"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not","for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total","the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\",",") assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias {name}.\\nBy changing","[str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\",","The vColumn {} was transformed using a mean encoding with {} as Response","(\"x\", x, [int, float]), ] ) if func not in (\"log\", \"mod\", \"pow\",",") except: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \",","return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx: bool","list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of the search. See Also","def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def","+ \" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\"","= None avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format(","for elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self):","def slice(self, length: int, unit: str = \"second\", start: bool = True): \"\"\"","|_) # \\/ (/_| | |(_(_|| \\/ # / # VerticaPy is a","{} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else:",") else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem in","cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({})","'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for k in","vColumn using 'count' (Number of non-Missing elements). Returns ------- int number of non-Missing","the vColumn. Parameters ---------- func: str, Function in pure SQL used to transform","\" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" ---------------------------------------------------------------------------","trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations += [trans]","(\"n\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if","numerical value\" ) lower_when = ( \"WHEN {} < {} THEN {} \".format(\"{}\",","AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS","print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias, conj,","or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1",") total, query, nth_elems = nb, [], [] while total < int(float(count /","COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query +=","\"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique()","(\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by","\"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None","of decimal places sign : arithmetic sign sin : trigonometric sine sinh :","The Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif","Returns ------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate :","store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result","pie chart. auto : Regular pie chart. donut : Donut chart. rose :","--------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See Also --------","is empty\\nIf you want to normalize by grouping by elements, please use a","self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations","ConversionError( \"{}\\nThe vColumn {} can not be converted to {}\".format( e, self.alias, dtype","Also -------- vDataFrame[].tail : Returns the a part of the vColumn. \"\"\" return","vDataFrame.filter: Filters the data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias))","axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn","trained if the response is numerical (except ints and bools), a RF Classifier","str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of the","= \"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun =","instead of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part :","2) elif h > 0.0001: h = round(h, 4) elif h > 0.000001:","of a numerical column for each vColumn category. In this case, the parameter","drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] +","case of discretization using the method 'same_freq'\" ) count = self.count() nb =","check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return","[str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ]","vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the","an offset and a limit). Parameters ---------- limit: int, optional Number of elements","/\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\ \\ # \\","self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]:",") ) return self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","of: str, optional The vColumn to use to compute the aggregation. h: int/float/tuple,","[str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]), ]","computed. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","None) or (upper != None), ParameterError( \"At least 'lower' or 'upper' must have","by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors =","self.isdate(), ) if (is_date) and not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\",","License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS","= 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with","'n' must be greater or equal to 1\") where = \" WHERE {}","vColumn based on an aggregation. Parameters ---------- method: str, optional The method to","trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent","= \"\", method: str = \"density\", of: str = \"\", max_cardinality: Union[int, tuple]","self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem] =","(\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError(","Draws the bar chart of the vColumn based on an aggregation. Parameters ----------","warning_message = ( \"label_encode is only available for categorical variables.\" ) warnings.warn(warning_message, Warning)","See Also -------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns.","width of the bar. If empty, an optimized h will be computed. ax:","PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS","= (6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ):","] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return","vColumn can only have one parent. catalog: dict, optional Catalog where each key","self.max() else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for","For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n","= \"\" if (k < 1) else \"LIMIT {}\".format(k) dropna = \" WHERE","\"float\", \"float\", ) ] else: warning_message = \"Can not normalize {} using a","if cmax - cmin == 0: warning_message = \"Can not normalize {} using","Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds","\"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns","prefix = \"approx_\" if approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][","/ # \\ / / / # \\ / / / # \\_______/","Parameters ---------- length: int Slice size. unit: str, optional Slice size unit. For","split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 ) result = executeSQL( query=query,","optional vColumns used in the partition. return_trans: bool, optimal If set to True,","the data. bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional","categories and merge the other into one unique category. h: float, optional The","to create a new category : 'Others'. cat_priority: list, optional List of the","< {} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else \"\"","the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\",","(must be > 1) k: int, optional The integer k of the 'topk'","/ (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \"sturges\": best_h =","{} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL(","non-missing elements q% : q quantile (ex: 50% for the median) prod :","mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See","# # Methods # # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\"Computing the average of","h will be picked or computed) nbins: int, optional Number of bins. If","= \"density\", of: str = \"\", max_cardinality: Union[int, tuple] = (6, 6), h:","# ---# def median( self, approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates","if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\"","Uses only categorical aggregations during the computation. cat_stats : Computes statistics of a","+= ( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \"","def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # # ---#","self.isnum() or self.isdate(), TypeError( \"cut only works on numerical / date-like vColumns.\" )","the regular expression in each record of the vColumn. vDataFrame[].extract : Extracts the","If empty, an optimized h will be computed. pie_type: str, optional The type","# ---# def normalize( self, method: str = \"zscore\", by: list = [],","start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be","self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem in","standard deviation topk : kth most occurent element (ex: top1 for the mode)","Parameters ---------- func: str Function to use to transform the vColumn. abs :","else 0 for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k)","print(\"Nothing was filled.\") self.transformations = [elem for elem in copy_trans] for elem in","from the different categories to [0, n - 1] (n being the vColumn","cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes","(\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by","beautiful graphical options. # # VerticaPy aims to do all of the above.","By setting this parameter to False, the function's performance can drastically decrease. Returns","n = 1 then this method will return the mode of the vColumn.","records by an input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat,","\"MEDIAN\" if (method == \"median\") else \"AVG\" if by == []: if fun","): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an","median) / (1.4826 * mad) minmax : Normalization using the MinMax (min and","the parameter 'x' will represent the number of seconds, otherwise it will represent",") warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\"'\", \"''\") if","start: bool, optional If set to True, the record will be sliced using","they occur, and other statistical information. Parameters ---------- k: int, optional Number of","self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat: str): \"\"\"","if self.category() == \"float\" else \"\" if index < 0: index += self.parent.shape()[0]","h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max(","to use to determine if the vColumn will be considered as categorical. numcol:","be numerical to use a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len(","already the alias {name}.\\nBy changing the parameter 'name', you'll be able to solve","left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import","Unless required by applicable law or agreed to in writing, software # distributed","(), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {}","abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List of the","self, threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05","vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds","vColumn 'of' (ex: 50% to get the median). It can also be a","[bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1,","= (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date]","input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False,","data when 'ts' is greater than November 1993 the 3rd. area: bool, optional","IS NOT NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n","set to True, the Median will be drawn. ax: Matplotlib axes object, optional","= {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total =","Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \"\"\" check_types([(\"n\", n,",": Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using","of {} partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif","] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and method","/ binary / spatial / uuid / undefined Returns ------- str vColumn category.","else \"\", stddev ), \"float\", \"float\", ) ] elif method == \"robust_zscore\": if","--------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool, optional If","x: float If the vColumn type is date like (date, datetime ...), the","= self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h,","elem in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\",",": Encodes the vColumn using the mean encoding of a response. \"\"\" check_types(","normalize {} using the MIN and the MAX. MAX = MIN !\".format( self.alias","the vColumn {} named {} was added to the vDataFrame.\".format( self.alias, name )","# \\/ # _ # \\ / _ __|_. _ _ |_) #","response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is only","check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {} WHERE {} IS","vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT","# _____________ / / # \\ / / / # \\ / /","] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn","desc = \"\" if (method in (\"ffill\", \"pad\")) else \" DESC\" partition_by =",") if return_trans: return \"({} - {}) / {}({} - {})\".format( self.alias, cmin,","The vColumn type must be date like (date, datetime, timestamp...) or numerical. by:","dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers","woe, CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE","[int, float]), (\"h\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =","p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({}","bins. smart : Uses the Random Forest on a response column to find","vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if","(dropna) and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\"Parameter 'n'","(\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]),","[\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def kurtosis(self):","val = self.avg() elif fun == \"MEDIAN\": val = self.median() new_column = \"COALESCE({},","n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not","), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias)","be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the","ffill|pad|bfill|backfill then 'order_by' must be a list of at least one element to","See Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding.","Adds a new vColumn labeled with 0 and 1 (1 meaning global outlier).","-------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a new","# # VerticaPy aims to do all of the above. The idea is","mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns -------","def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \"vColumn","considered during the computation. Returns ------- tablesample An object containing the result. For","( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ]",": Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by = [by]","if nbins <= 0: h = self.numh() else: h = (self.max() - self.min())","nbins: int, optional Number of bins. If empty, an optimized number of bins","result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"]","= self.avg() elif fun == \"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\",",">= 1, ParameterError(\"Parameter 'n' must be greater or equal to 1\") where =","(No h will be picked or computed) nbins: int, optional Number of bins.","columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name: str =","max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for","during the computation. max_cardinality: int, optional Cardinality threshold to use to determine if","* 1.01 / nbins if h > 0.01: h = round(h, 2) elif","kernel: str, optional The method used for the plot. gaussian : Gaussian kernel.","category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func","elif (method == \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category()","pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of","[\"unique\", \"count\"] + [item[0] for item in query_result] else: result = ( self.parent.describe(","_ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # /","NULL \".format(self.alias) if (dropna) else \" \" result = executeSQL( \"SELECT {} FROM",": Freedman Diaconis [2 * IQR / n ** (1 / 3)] sturges",": Draws the Bar Chart of vColumn based on an aggregation. \"\"\" check_types(","aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n:","the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","\"min\", \"max\"]) index = result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\") and","lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to","3rd. end_date: str / date, optional Input End Date. For example, time =","the 3rd. plot_median: bool, optional If set to True, the Median will be","aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int,","intervals will be closed on the right. Returns ------- vDataFrame self.parent See Also","(ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {})","see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\" columns = [self.alias]","'{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr, \"bool\",","self.alias, text_info ) ) return self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates","See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize","nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query =","VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import * from","return_trans: return \"({} - {}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if","self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element","h: float, optional Interval width if the vColumn is numerical or of type","\"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]),","len(args) > 0: column = args[0] elif \"column\" in kwargs: column = kwargs[\"column\"]","category)] try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,","for i in range(1, n): trans += \"WHEN {} BETWEEN {} AND {}","), \"float\", \"float\", ) ] elif method == \"robust_zscore\": if n > 0:","elem in transformations], ) self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\": {},","the mean encoding of a response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message","\"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826 elif method == \"zscore\":","to use to aggregate the data. count : Number of elements. density :","{} FROM {} WHERE {} IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias,","self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step","\"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[2] if elem[2]","is date like). The vColumn will be transformed. Parameters ---------- field: str The","for item in result], \"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2], 3))","({}) x\".format( self.alias, query, ) query = \"SELECT {} AS index, non_events, events,","ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE",": Rose chart. It can also be a cutomized aggregation (ex: AVG(column1) +","Returns the vColumn database type. \"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None,","the data\" ) desc = \"\" if (method in (\"ffill\", \"pad\")) else \"","optional Offset. Returns ------- tablesample An object containing the result. For more information,","the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law","= \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func:","vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn to use","IS NOT NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n","LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types(","be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias","{} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting","(isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if","[], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent,","the method 'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble","h, h, h, floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({}) ||","\"int\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\") else","included. right: bool, optional How the intervals should be closed. If set to",") custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ]",": approximative cardinality count : number of non-missing elements cvar : conditional value","parent and do not apply it. This parameter is very useful for testing","'\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has","self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \"\", prefix_sep: str","the different transformations. \"\"\" # # Special Methods # # ---# def __init__(","see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table.","--------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str, optional Method","record of the vColumn. The vColumn will be transformed. Parameters ---------- pat: str","used to cut the vColumn. labels: list, optional Labels used to name the","# ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn. The","ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to normalize.\", method=\"fetchall\", )","optional The method to use to aggregate the data. count : Number of","get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT","\"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\",","If empty, an optimized number of bins will be computed. h: float, optional","vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')","self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\"Computing the equal","with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode :","robust_zscore : Normalization using the Robust Z-Score (median and mad). (x - median)","round(h, 4) elif h > 0.000001: h = round(h, 6) if self.category() ==","vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \"\"\" check_types( [","schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\")","\\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-. \\ # \\","\"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\",","index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0]","WHEN {} > {} THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\",","), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format(","In this case, the parameter 'numcol' must be defined. numerical : Uses popular","logarithm mod : remainder of a division operation pow : number raised to","'labels' must be empty.\" ) conditions, column = [], self.alias for idx in","\"float\", ) ] else: warning_message = \"Can not normalize {} using a Robust","equals to 2 in case of discretization using the method 'topk'\" ) distinct","Returns the n smallest elements in the vColumn. Parameters ---------- n: int, optional","2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"),","use to sort the data when using TS methods. Returns ------- vDataFrame self.parent",") method = method.lower() if self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"]","delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was","dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format(","x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ----------","optional Catalog where each key corresponds to an aggregation. vColumns will memorize the","{}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {} to","is greater than November 1993 the 3rd. plot_median: bool, optional If set to","result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result =","(float, int))) else \"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\")","parameter to False, the function's performance can drastically decrease. Returns ------- float quantile","\"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return \"({} -","Returns the vColumn expected store usage (unit: b). Returns ------- int vColumn expected","by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \"method\",","the TS. start_date: str / date, optional Input Start Date. For example, time","-------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]),","method. Parameters ---------- method: str, optional Method to use to fill the vColumn","\"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self):","alias, [elem for elem in transformations], ) self.catalog = { \"cov\": {}, \"pearson\":","See Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail :","else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans = (\"{} ||","if labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}'","] # ---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75),",": mode (most occurent element). 0ifnull : 0 when the vColumn is null,","same_width : Computes regular width bins. smart : Uses the Random Forest on","columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider","be considered during the computation. Returns ------- tablesample An object containing the result.","vColumn labeled with 0 and 1 (1 meaning global outlier). \"\"\" check_types( [","\"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT {}","search. Parameters ---------- val: list List of the different records. For example, to",": median min : minimum mode : most occurent element percent : percent","doesn't allow slicing having steps different than 1.\" ) index_stop = index.stop index_start","return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else","best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h","user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode :","return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int = 10):","query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0]",": Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def","0.01: h = round(h, 2) elif h > 0.0001: h = round(h, 4)","\\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\","than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers","cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn","numerical. q: tuple, optional Tuple including the 2 quantiles used to draw the","\"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list =","= 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ----------","self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except:","bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \"SELECT {}","self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"] = 0","item in result], \"percent\": [float(round(item[2], 3)) for item in result], } return tablesample(values)","optional If set to True, the record will be sliced using the floor","in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for","the vColumn by keeping only the input number of digits after the comma.","Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if","be similar to the following: (function, type, category) parent: vDataFrame, optional Parent of",": Draws the Box Plot of the input vColumns. \"\"\" if isinstance(cat_priority, str)","\"\", h: float = 0, max_cardinality: int = 8, cat_priority: list = [],","return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]),","str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \", \"_\") .replace(\"/\", \"_\") .replace(\",\",","\"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(),","the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True if","\"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL","< 50): try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT","will look like: even: CASE ... WHEN vColumn = argv[2 * i] THEN","vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode","\"tanh\", ], ), (\"x\", x, [int, float]), ] ) if func not in","\\ / / / # \\_______/ / / # ______ / / #","self.alias, self.alias, self.alias, ) else: query = \"SELECT {} FROM (SELECT {} AS","Plot. step: bool, optional If set to True, draw a Step Plot. ax:","result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise","if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = []","if (nullifzero) else \"\", stddev ), \"float\", \"float\", ) ] elif method ==","distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY","the discretization (must be > 1) k: int, optional The integer k of","= \"winsorize\", threshold: float = 4.0, use_threshold: bool = True, alpha: float =","by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]),","self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for","self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name,","in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to","discretization using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE","Computes the Information Value (IV) / Weight Of Evidence (WOE) Table. It tells","\"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\":","\"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ] ) if","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var See","if the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category","tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime,","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar","will be updated when the parent vDataFrame is modified. Attributes ---------- alias, str","\"minmax\": if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias]","Adds the input element to the vColumn. Parameters ---------- x: float If the","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg","quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method",") self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self,","[int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title","with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(),","self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try: result =","dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers","approx: bool, optional If set to True, the approximate median is returned. By","\"regr_syy\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def","executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False,","vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn","!= 0, Exception( \"Not enough values to compute the Equal Frequency discretization\" )","is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1)","(\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans = (\"{} || ''\", \"varchar\", \"text\")","as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by: str =","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular","\"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev","= \"CASE WHEN \" + \" WHEN \".join(conditions) + \" END\" self.apply(func=expr) #","[int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int","vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" )","float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\":","elements to display. offset: int, optional Number of elements to skip. Returns -------","area: bool = False, step: bool = False, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","sum std : standard deviation topk : kth most occurent element (ex: top1","result.values[self.alias] elif (method == \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert","Random Forest model parameters used to compute the best splits when 'method' is","Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])])","(\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias:","the final generated SQL code. Note: Dropping a vColumn can make the vDataFrame","and a maximum depth of 10. response: str, optional Response vColumn when method","\"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn =","Filters the data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return","geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\" columns = [self.alias] check =","bijection from the different categories to [0, n - 1] (n being the","* {} || ';' || (FLOOR({} / {}) * {} + {}{}) ||","USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =","analytical function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate","= \"<=\", \"[\" elif idx == 0: op1, close_l = \"<\", \"]\" if","pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only","find the most relevant interval to use for the discretization. topk : Keeps","to be used as categorical. The less frequent elements will be gathered together","optional Uses the threshold instead of the 'alpha' parameter. alpha: float, optional Number","the current axes. ax: Matplotlib axes object, optional The axes to plot on.","\"{}\", h, h, \"{}\", h, h, h, floor_end ), \"varchar\", \"text\", ) else:","mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters","var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var","Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert","aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns -------","otherwise. Returns ------- bool True if the vColumn is boolean. See Also --------","transformations. Each transformation must be similar to the following: (function, type, category) parent:","to {}\".format( e, self.alias, dtype ) ) # ---# def avg(self): \"\"\" ---------------------------------------------------------------------------","vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist( self, method: str = \"density\",","See Also -------- vDataFrame.donut : Draws the donut chart of the vColumn based","max, median, unique... depending on the input method. Parameters ---------- method: str, optional","VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query,","to in writing, software # distributed under the License is distributed on an","NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method == \"mean\": query","\"Length of parameter breaks must be equal to the length of parameter 'labels'","the data. The vColumn type must be date like (date, datetime, timestamp...) or","), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and method ==","vColumns 1 and 2 bars. It is only valid if the vColumns are","cardinality count : number of non-missing elements cvar : conditional value at risk","{}{}) || ']'\".format( \"{}\", h, h, \"{}\", h, h, h, floor_end ), \"varchar\",","most relevant interval to use for the discretization. topk : Keeps the topk","function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x !=","elif method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN","model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result =","4.0, use_threshold: bool = True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops","input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","GROUP BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY","most occurent element (ex: top1 for the mode) topk_percent : kth most occurent","{}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\"Computing","nullifzero, n = 1, len(by) if self.isbool(): warning_message = \"Normalize doesn't work on","\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY","stddev == 0: warning_message = \"Can not normalize {} using a Z-Score -","/ date, optional Input Start Date. For example, time = '03-11-1993' will filter","[int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x))","vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn.","the vColumn distinct elements to be used as categorical (No h will be","Exception as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error","delimitor of the dummies. drop_first: bool, optional Drops the first dummy to avoid","h: float, optional The interval size to convert to use to convert the","---# def topk(self, k: int = -1, dropna: bool = True): \"\"\" ---------------------------------------------------------------------------","\"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {} WHERE {}","categories will be filtered. ax: Matplotlib axes object, optional The axes to plot","DOQ / DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK","\"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1] == None) else str(elem[1]) new_column","AS iv FROM ({}) x ORDER BY ord\".format( self.alias, query, ) title =","/ {} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC","of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int,","> 1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]:","mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent # ---# def fillna(","= \"\", max_cardinality: int = 6, h: float = 0, pie_type: str =","the lowest element of the list will be included. right: bool, optional How",": Percentage of the distribution. mean : Average of the vColumn 'of'. min","1)) floor_end = -1 if (self.category() == \"int\") else \"\" if (h >","use_threshold: bool = True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers","kwargs: column = kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column) column =","will be filtered. ax: Matplotlib axes object, optional The axes to plot on.","display. offset: int, optional Number of elements to skip. Returns ------- tablesample An","\"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a","idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5],","result, } if ((is_date) and not (method == \"categorical\")) or ( method ==",") return self.parent # ---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the","of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\",","self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x:","most occurent elements to return. Returns ------- tablesample An object containing the result.","bound itself and the values higher than the upper bound to the upper","\"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif","result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the","END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type.","\"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"',","VerticaPy brings the logic to the data. # # # Modules # #","self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(),","the License is distributed on an \"AS IS\" BASIS, # WITHOUT WARRANTIES OR","pie chart. donut : Donut chart. rose : Rose chart. It can also","number round : rounds a value to a specified number of decimal places","a function to the vColumn. Parameters ---------- func: str, Function in pure SQL","(schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert","governing permissions and # limitations under the License. # # |_ |~) _","of the record is greater than the threshold it will be considered as","self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx: bool =","ctype # ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS",": Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\",","outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped.","float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut","during the computation. Returns ------- tablesample An object containing the result. For more","using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True, the","to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"),","(n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT {},","empty, an optimized h will be computed. pie_type: str, optional The type of","---# def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns the k most","result[i] ) trans += \" ELSE NULL END)\" trans = (trans, \"varchar\", \"text\")","using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the","( \"WHEN {} > {} THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float,","style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4,","< 1) else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS NOT NULL\".format(self.alias)","plot on. **style_kwds Any optional parameter to pass to the Matplotlib functions. Returns","not be converted to {}\".format( e, self.alias, dtype ) ) # ---# def","vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum : Returns","ts: str, by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date:","optional Integer corresponding to the offset. For example, if n = 1 then","name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy","method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp","xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return","use to partition the TS. start_date: str / date, optional Input Start Date.","Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1]","AS {} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),","vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date =","see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to the","/ YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the","dropna, [bool]), (\"n\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias,","vColumn 'of'. max : Maximum of the vColumn 'of'. sum : Sum of","approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns","the approximate density function. Increasing this parameter will increase the precision but will","standard error of the mean skewness : skewness sum : sum std :","self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns","Value to use to impute the vColumn. method: dict, optional Method to use","log : logarithm log10 : base 10 logarithm mod : remainder of a","varchar. same_freq : Computes bins with the same number of elements. same_width :","For example to apply the function: x -> x^2 + 2 use \"POWER({},","0 when the vColumn is null, 1 otherwise. expr: str, optional SQL expression.","(method == \"mode\") and (val == None): val = self.mode(dropna=True) if val ==","FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev","category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total","hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor : value","== 0: op1, close_l = \"<\", \"]\" if labels: label = labels[idx] else:","method=\"fetchall\", ) for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]):","vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns","[self.max()] elif method == \"topk\": assert k >= 2, ParameterError( \"Parameter 'k' must","n = \"\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top","n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" ---------------------------------------------------------------------------","by an input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])])","optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies","vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew","vColumns used in the partition. order_by: list, optional List of the vColumns to","self, method: str = \"winsorize\", threshold: float = 4.0, use_threshold: bool = True,","-------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"n\", n,","method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])]) assert (lower !=","the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use to","vColumn missing values. \"\"\" if isinstance(by, str): by = [by] if isinstance(order_by, str):","average absolute deviation approx_unique : approximative cardinality count : number of non-missing elements","timestamp...) or numerical. by: str, optional vColumn to use to partition the TS.","start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" ---------------------------------------------------------------------------","**kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any","determine if the vColumn will be considered as categorical. numcol: str, optional Numerical","2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func:","* FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL","}, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features","), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column","'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True, the approximate","use for the discretization. topk : Keeps the topk most frequent categories and","\"numerical\")) or not (is_numeric) or (method == \"categorical\") ): query = \"\"\"(SELECT {0}","2 bars. It is only valid if the vColumns are numerical. Optimized h","10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE)","if elem[2] != None else \"NULL\", ) for elem in result if elem[2]","optional The vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval","the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix","NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category =","x -> x^2 + 2 use \"POWER({}, 2) + 2\". copy_name: str, optional","if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} <","elif method == \"topk\": assert k >= 2, ParameterError( \"Parameter 'k' must be","[ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\",","of pie chart. auto : Regular pie chart. donut : Donut chart. rose","\"The vColumn {} has no mode (only missing values).\\nNothing was filled.\".format( self.alias )","absolute deviation max : maximum mean : average median : median min :","all of the above. The idea is simple: instead of moving # data","method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result + [self.max()]","the data. method: str, optional The method to use to aggregate the data.","---------- by: str, optional vColumn to use to partition the data. method: str,","the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of the","the vColumn from the vDataFrame. Dropping a vColumn means simply not selecting it","by dropping the current vColumn and creating a copy with the specified name.","# # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores all","of the bar. If empty, an optimized h will be computed. pie_type: str,","to do all of the above. The idea is simple: instead of moving","having steps different than 1.\" ) index_stop = index.stop index_start = index.start if","to look at the final transformation. Returns ------- vDataFrame self.parent See Also --------",": arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt :","be used as categorical. The less frequent elements will be gathered together to","{}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count =","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression.","val = [val] val += list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val}","optional The interval size to convert to use to convert the vColumn. If","One hot encoder was applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features),","by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {} to normalize.\".format(","SQL used to transform the vColumn. The function variable must be composed of",": Returns True if the vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\",","if isinstance(val, str): val = val.replace(\"'\", \"''\") if val != None: new_column =","------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a","self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias]","\"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int,","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str,","method != \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias,","(the \"License\"); # You may not use this file except in compliance with","must be a vDataFrame column if the method is 'cat_stats'\" ) distinct_count, is_numeric,","method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name",") transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent,","otherwise it will represent a number. Returns ------- vDataFrame self.parent See Also --------","See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method.","def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions.","result = executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem","int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ----------","\"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int","h: float = 0, pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {})","[\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method =","self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles","(SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias,","nbins. If empty, an optimized number of nbins will be computed. h: float,","in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max(","(self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias of one of the dummies","sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","by[0], ), title=\"Computing the different categories to normalize.\", method=\"fetchall\", ) for i in","{}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int):","title=title) # ---# def normalize( self, method: str = \"zscore\", by: list =","to discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast","return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory","Any amount of expressions. The expression generated will look like: even: CASE ...","== \"AVG\": val = self.avg() elif fun == \"MEDIAN\": val = self.median() new_column","pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns","pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also","response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {},","nbins - 1 ) result = executeSQL( query=query, title=\"Computing the optimized histogram nbins","best_h # ---# def nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the","boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn category is","q: tuple, optional Tuple including the 2 quantiles used to draw the Plot.","return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by: str = \"\", bandwidth:","iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad :","= self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func 'x","step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","= val # # Methods # # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates","increase the precision but will also increase the time of the learning and","cut the vColumn. labels: list, optional Labels used to name the new categories.","# ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True,","else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str = \"density\", of:","self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max","numerical. Optimized h will be computed if the parameter is empty or invalid.","= gen_colors() if not xlim: xmin = self.min() xmax = self.max() else: xmin,","(except ints and bools), a RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\":","k: int, optional Number of most occurent elements to return. Returns ------- tablesample","model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias],","\"fd\", \"auto\"])] ) method = method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias,","to the next whole number cos : trigonometric cosine cosh : hyperbolic cosine","[list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot","None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ----------","Parameters ---------- method: str, optional Method to use to fill the vColumn outliers.","(\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] )","on the input method. Parameters ---------- method: str, optional The describe method. auto","/ / # |____/ / / # _____________ / / # \\ /","executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0]","vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn","nbins if h > 0.01: h = round(h, 2) elif h > 0.0001:","labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1}","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations","self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset","transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str, optional New","BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i","\\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-. \\","decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate","vColumn records. vDataFrame[].str_count : Computes the number of matches for the regular expression","\"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None): return","{} WHEN {} > {} THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha,","# ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns -------","the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be","be closed on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply","== 0: warning_message = \"Can not normalize {} using the MIN and the","if the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is","Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot","aggregate the data. count : Number of elements. density : Percentage of the","Warning) return self elif method == \"minmax\": if n == 0: nullifzero =","category : 'Others'. cat_priority: list, optional List of the different categories to consider","utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn. \"\"\"",") method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by)","1] if right: op1, op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else:","/ MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE","2 quantiles used to draw the Plot. start_date: str / date, optional Input",": Fills the vColumn outliers using the input method. \"\"\" check_types([(\"lower\", lower, [float,","((distinct_count < max_cardinality + 1) and (method != \"numerical\")) or not (is_numeric) or","digits after the comma. Parameters ---------- n: int Number of digits to keep","desc for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({}",": Normalization using the MinMax (min and max). (x - min) / (max","\"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\",","check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime,","sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem in","Iterable)): val = [val] val += list(args) check_types([(\"val\", val, [list])]) val = {self.alias:","'new_name', you'll be able to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False)","Replaces the regular expression matches in each of the vColumn records by an","= \"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events,","BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna,","): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an","e: raise QueryError( \"{}\\nError when applying the func 'x -> {}' to '{}'\".format(","cvar : conditional value at risk dtype : vColumn type iqr : interquartile","-------- vDataFrame[].dropna : Drops the vColumn missing values. \"\"\" if isinstance(by, str): by","Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","# ---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the","= \"int\", \"bool\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for","= str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types(","method. Parameters ---------- method: str, optional The method to use to discretize the","0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE","int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ----------","-------- vDataFrame[].str_contains : Verifies if the regular expression is in each of the","): \"\"\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on","ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel","\"count\"] + [item[0] for item in query_result] else: result = ( self.parent.describe( method=\"numerical\",","\".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"),","of the distribution. mean : Average of the vColumn 'of'. min : Minimum","float A float between 0 and 1 that represents the quantile. For example:","can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes","( \"({} - {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero)","See the License for the specific language governing permissions and # limitations under","following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of the search. See","= [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h,","val = self.mode(dropna=True) if val == None: warning_message = \"The vColumn {} has","[int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else \"\" return","* {} + {}{}) || ']'\".format( \"{}\", h, h, \"{}\", h, h, h,","\"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds,","= (trans, \"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations += [trans] sauv","of the different aggregation. aad : average absolute deviation approx_unique : approximative cardinality","if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] )","mean : average median : median min : minimum mode : most occurent","NameError( f\"A vColumn has already the alias {name}.\\nBy changing the parameter 'name', you'll","values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method","--------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int, optional Number","\"Can not normalize {} using a Robust Z-Score - The MAD is null","if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__(","5). ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","str, optional Method to use to fill the vColumn outliers. mean : Replaces","optional Dictionary of the Random Forest model parameters used to compute the best","axes object See Also -------- vDataFrame.donut : Draws the donut chart of the","} for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index):","the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS","True if the vColumn is numerical. \"\"\" return self.category() == \"date\" # ---#","records by an input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int,","= 'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT","self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem","Uses method 'same_width' for numerical vColumns, cast the other types to varchar. same_freq","x)) # ---# def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the","bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()),","normalizing the data (Z-Score), if the absolute value of the record is greater","2, TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) response_cat =","learning features. It supports the # entire data science life cycle, uses a","The vColumn {} was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs):","pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826","iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn","and machine learning features. It supports the # entire data science life cycle,","{}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ), \"float\",","If not empty, a copy will be created using the input Name. Returns","\\ / / /\\ ___\\ /\\ __ \\ /\\ \\ /\\ \\/\\ \\","\"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \"\"\" ---------------------------------------------------------------------------","if not (dropna): n = \"\" if (n == 1) else str(int(n)) if","\"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ---------- method:","self.alias, topk, ) result = executeSQL( query, title=\"Computing the top{} categories of {}.\".format(","---------- lower: float, optional Lower bound. upper: float, optional Upper bound. Returns -------","100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,","------- float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])]","[int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ] ) start_or_end = \"START\"","in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return","float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by)","[ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h,","\"\"\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset and","column for each vColumn category. In this case, the parameter 'numcol' must be","if the parameter is empty or invalid. max_cardinality: int, optional Maximum number of","= \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim]","(No h will be picked or computed) nbins: int, optional Number of nbins.","var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return",") distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN ({}) THEN","vColumn. Parameters ---------- func: str, Function in pure SQL used to transform the","\"vColumn {} must be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort()","= \"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","n = len(result) trans = \"(CASE \" for i in range(1, n): trans","return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the","if the vDataFrame has been transformed multiple times, so it's better practice to","i ) for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT","str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT","[]: if fun == \"AVG\": val = self.avg() elif fun == \"MEDIAN\": val","# ---# def numh(self, method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal",".transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4],","vColumn outliers using the input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper,","Slices and transforms the vColumn using a time series rule. Parameters ---------- length:","like). The vColumn will be transformed. Parameters ---------- field: str The field to","with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else:","1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0","different vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent","str = \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of","the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk","q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\",","= get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL","successfully done.\") return self.parent # ---# def median( self, approx: bool = True,","method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad","in result], \"percent\": [float(round(item[2], 3)) for item in result], } return tablesample(values) #","{}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem]","optional Interval width of the vColumns 1 and 2 bars. It is only","base 10 logarithm mod : remainder of a division operation pow : number","\"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn)","the regular expression is in each of the vColumn records. vDataFrame[].str_count : Computes","= [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \"method\", method,","a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a","product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","= ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER","= ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if","): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts:","in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif","self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result","0, h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram",") # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average).","\"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit:","the vColumn. vDataFrame[].extract : Extracts the regular expression in each record of the","else \"\" query = \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 *","re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except:","self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors","sublist] # ---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by","order_by] + by) by = self.parent.format_colnames(by) if method == \"auto\": method = \"mean\"","is lesser than November 1993 the 3rd. end_date: str / date, optional Input","each of the vColumn records by an input value. \"\"\" check_types([(\"start\", start, [int,","] ) start_or_end = \"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {},","so it's better practice to use this method when first preparing your data.","than the threshold it will be considered as an outlier. use_threshold: bool, optional","vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates","== 1: lp, rp = \"(\", \")\" else: lp, rp = \"\", \"\"","index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit","(\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]),","= \"mean\" if (self.isnum() and self.nunique(True) > 6) else \"mode\" total = self.count()","# ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is","\"pad\")) else \" DESC\" partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for","] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax, cmin,","the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]), (","if len(args) > 0: column = args[0] elif \"column\" in kwargs: column =","if the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True","if len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" ---------------------------------------------------------------------------","It supports the # entire data science life cycle, uses a ‘pipeline’ mechanism","numerical for Normalization\") return self.parent # ---# def nsmallest(self, n: int = 10):","a Robust Z-Score - The MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning)","+= [(new_column, ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem]","------- tablesample An object containing the result. For more information, see utilities.tablesample. See","= [], return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns","method is 'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), )","Returns ------- bool True if the vColumn category is date. See Also --------","width if the vColumn is numerical or of type date like. Optimized h","/ ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else: warning_message = \"Can not","{}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\",","\"{}\", h, h, h, floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({})","filtered. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","except: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","/ / # | \\/ / / / # |______ / / /","use to fill the vColumn outliers. mean : Replaces the upper and lower",") self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent #","[elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor:","FROM ({}) x\".format( self.alias, query, ) query = \"SELECT {} AS index, non_events,","elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","example, time = '03-11-1993' will filter the data when 'ts' is lesser than","\"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in by]) ) if (by) else","to evaluate the approximate density function. Increasing this parameter will increase the precision","title = \"Reads {} {} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---#","self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number","column in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))),","== 0 and include_lowest: op1, close_l = \"<=\", \"[\" elif idx == 0:","updated when the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn","self.alias, self.alias, ) else: query = \"SELECT {} FROM (SELECT {} AS {},","{}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return self.parent except Exception as e:","= self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN ({}) THEN {} ||","'by' is empty\\nIf you want to normalize by grouping by elements, please use","bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to False","+= \"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations","<= 0: h = self.numh() else: h = (self.max() - self.min()) * 1.01","return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str =","vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum number of","isinstance(method, str): method = method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\",","to extract. It must be one of the following: CENTURY / DAY /","Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","ANY KIND, either express or implied. # See the License for the specific","= self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format(","vColumn {} was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \"\"\"","the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category is","vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \"\"\"",": vColumn type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera","vColumn based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel,","and (method != \"numerical\")) or not (is_numeric) or (method == \"categorical\") ): query","approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters","alias of one of the dummies ({name}).\\n\" \"It can be the result of","GROUP BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"],","Encodes the vColumn using the average of the response partitioned by the different","precision but will also increase the time of the learning and scoring phases.","Computes regular width bins. smart : Uses the Random Forest on a response","categories of the vColumn. Returns ------- list Distinct caterogies of the vColumn. See","= self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={","by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime,","cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category","\"\", self.alias ), method=\"fetchall\", ) values = { \"index\": [item[0] for item in","\".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \"SELECT {}","[bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \"cut only works on numerical","response: str, optional Response vColumn when method is set to 'smart'. return_enum_trans: bool,",") # ---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression","( \"WHEN {} < {} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float,","= [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format =","nbins: int, optional Number of nbins. If empty, an optimized number of nbins","skewness : skewness sum : sum std : standard deviation topk : kth","optional Input Start Date. For example, time = '03-11-1993' will filter the data","vColumn has already the alias of one of the dummies ({name}).\\n\" \"It can","NULL value. winsorize : Clips the vColumn using as lower bound quantile(alpha) and","# ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of","if n = 1 then this method will return the mode of the","if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1]","= 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of the","because of ambiguous columns naming.\\nBy changing one of \" \"the parameters ('prefix', 'prefix_sep'),","parameters ('prefix', 'prefix_sep'), you'll be able to solve this \" \"issue.\" ) for","element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See Also","if limit <= 0: limit = 0 limit = \" LIMIT {}\".format(limit) else:","distinct) var : variance Other aggregations could work if it is part of","0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop","for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1]","the data (Z-Score), if the absolute value of the record is greater than","values. \"\"\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by =","average of the response partitioned by the different vColumn categories. Parameters ---------- response:","\"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool = False, step: bool","the top{} categories of {}.\".format( k if k > 0 else \"\", self.alias","AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title","Encoding]: Label Encoding was applied to the vColumn {} using the following mapping:{}\".format(","cmin == 0: warning_message = \"Can not normalize {} using the MIN and","e, self.alias, dtype ) ) # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","\"Badr\"] Returns ------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin","was transformed using a mean encoding with {} as Response Column.\".format( self.alias, response","optional The axes to plot on. **style_kwds Any optional parameter to pass to","/ {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin,","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] #","= \"\" query = \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(),","utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types(",") if method in (\"mean\", \"median\") or isinstance(val, float): category, ctype = \"float\",","all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"variance\"]).values[self.alias][0] variance =","--------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent","Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix","time = '03-11-1993' will filter the data when 'ts' is greater than November","vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\"","limit = index_stop - index_start if limit <= 0: limit = 0 limit","nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop()","naming.\\nBy changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be able to","BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count","your data. Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame","self.transformations = [elem for elem in copy_trans] for elem in sauv: self.catalog[elem] =","{}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else:","\"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories to","the missing values. auto : Mean for the numerical and Mode for the","self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if","defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with","# ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns -------","\"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot(","\"{}\\nError when applying the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"),","-------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])])","self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor,","except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return self.parent #","Parent of the vColumn. One vDataFrame can have multiple children vColumns whereas one","the lower bound to the lower bound itself and the values higher than","(by) else \"\" ) order_by_ts = \", \".join([quote_ident(column) + desc for column in","cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \"MAX({}) OVER","format = 'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"]) ] query =","parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict","in relation to the dependent variable. Parameters ---------- y: str Response vColumn. nbins:","Subtracts the input element from the vColumn. Parameters ---------- x: float If the","param = {\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column)","is boolean, False otherwise. Returns ------- bool True if the vColumn is boolean.","better practice to use this method when first preparing your data. Parameters ----------","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit: int","limit). Parameters ---------- limit: int, optional Number of elements to display. offset: int,","plot of the vColumn. Parameters ---------- by: str, optional vColumn to use to","\\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-. \\ # \\ \\__|","= 0 limit = \" LIMIT {}\".format(limit) else: limit = \"\" query =","If empty, names will be generated. include_lowest: bool, optional If set to True,","Python library with scikit-like functionality for conducting # data science projects on data","labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND {column}","the response is numerical (except ints and bools), a RF Classifier otherwise. Example:","Parameters ---------- val: int/float/str, optional Value to use to impute the vColumn. method:","example to apply the function: x -> x^2 + 2 use \"POWER({}, 2)","Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1 /","== \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 / 1.4826 elif method ==","For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information","a vDataFrame column if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date =","columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations = [elem","[\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result #","prod = product # ---# def quantile(self, x: float, approx: bool = True):","x limits of the current axes. ax: Matplotlib axes object, optional The axes","= self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method,","aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","statistical aggregations: min, max, median, unique... depending on the input method. Parameters ----------","distinct elements to be used as categorical (No h will be picked or","threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha","The vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return parent # ---# def","from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step,","_____________ / / # \\ / / / # \\ / / /","function has two arguments (example, power or mod), 'x' represents the second argument.","will be computed. nbins: int, optional Number of bins used for the discretization","for column in by]) ) if (by) else \"\" ) order_by_ts = \",","See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\",",", 'categorical' otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats",": Donut chart. rose : Rose chart. It can also be a cutomized","...), the parameter 'x' will represent the number of seconds, otherwise it will","the input vColumns based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]),","k: int, optional Number of most occurent elements to return. dropna: bool, optional","vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the vColumn.","NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER","{} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format(","---------- approx: bool, optional If set to True, the approximate median is returned.","'of'. min : Minimum of the vColumn 'of'. max : Maximum of the","the computation. max_cardinality: int, optional Cardinality threshold to use to determine if the","the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\"","\"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE","val = val.replace(\"'\", \"''\") if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val)","in (\"bool\", \"boolean\") # ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the","== 0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev ==","value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in each","'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical : Uses only","= len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(),","total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations =","writing, software # distributed under the License is distributed on an \"AS IS\"","defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes","Uses the Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if","\"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column","[ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\",","bound quantile(1-alpha) if 'use_threshold' is set to False else the lower and upper","object See Also -------- vDataFrame.boxplot : Draws the Box Plot of the input","a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful graphical","--------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype: str New","{self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if","The vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum number","information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV)","[elem for elem in self.transformations] total = self.count() if method not in [\"mode\",","most occurent element. Parameters ---------- dropna: bool, optional If set to True, NULL","def mode(self, dropna: bool = False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns","\"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response","See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\" import sys","self.alias, where, ) result = executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\",","limit = \"\" query = \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias,","[str]), (\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"],","\"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---#","the parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations during","categories. If empty, names will be generated. include_lowest: bool, optional If set to","using the MinMax (min and max). (x - min) / (max - min)","MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER","(self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias {new_name}.\\nBy changing the parameter 'new_name',","numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [],","# # ---# def __init__( self, alias: str, transformations: list = [], parent=None,","True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool,","threshold instead of the 'alpha' parameter. alpha: float, optional Number representing the outliers","compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result","parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple children","\"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\",","ParameterError( \"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a list","will be picked or computed) nbins: int, optional Number of nbins. If empty,","Method to use to fill the vColumn outliers. mean : Replaces the upper","transformations: list, optional List of the different transformations. Each transformation must be similar","Clips the vColumn by transforming the values lesser than the lower bound to","stddev ), \"float\", \"float\", ) ] elif method == \"robust_zscore\": if n >","\"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\"","the predictive power of an independent variable in relation to the dependent variable.","h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\", method,","= { \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result, }","'aad' (Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate :","= len(result) trans = \"(CASE \" for i in range(1, n): trans +=","mean encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in","optional Input End Date. For example, time = '03-11-1993' will filter the data","Returns the k most occurent elements and their distributions as percents. Parameters ----------","k most occurent elements, how often they occur, and other statistical information. Parameters","1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION","- self.min()) * 1.01 / nbins if h > 0.01: h = round(h,","describe( self, method: str = \"auto\", max_cardinality: int = 6, numcol: str =","return self.parent except Exception as e: raise ConversionError( \"{}\\nThe vColumn {} can not","on the vColumn \" \"or simply because of ambiguous columns naming.\\nBy changing one","None ] ), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [","List of the different categories to consider when drawing the box plot. The","def plot( self, ts: str, by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date]","= 0, nbins: int = -1, k: int = 6, new_category: str =","Returns the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp","k if k > 0 else \"\", self.alias ), method=\"fetchall\", ) values =","= \"\", return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using","count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS","(ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to plot","), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method","be considered as an outlier. use_threshold: bool, optional Uses the threshold instead of","matches in each of the vColumn record by an input value. The vColumn",": Returns the vColumn database type. \"\"\" return self.transformations[-1][2] # ---# def clip(self,","if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total,","\", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\",","---# def hist( self, method: str = \"density\", of: str = \"\", max_cardinality:","whereas one vColumn can only have one parent. catalog: dict, optional Catalog where","vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a response. \"\"\"","else: if not (\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0]","'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame","query_result] index = [\"unique\", \"count\"] + [item[0] for item in query_result] else: result","normalize {} using a Z-Score - The Standard Deviation is null !\".format( self.alias","vDataFrame[].str_replace : Replaces the regular expression matches in each of the vColumn records","relation, a vColumn can be seen as one column of that relation. vColumns","for the numerical and Mode for the categorical vColumns. bfill : Back Propagation","average. null : Replaces the outliers by the NULL value. winsorize : Clips","getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return","(dropna) else \"\" query = \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100","ALL \".join(query), nbins - 1 ) result = executeSQL( query=query, title=\"Computing the optimized","TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame","< 0: index += self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET {}","(SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE {0} IS NOT NULL GROUP","str, optional vColumn to use to partition the data. bandwidth: float, optional The","return. Returns ------- tablesample An object containing the result. For more information, see","comma. Parameters ---------- n: int Number of digits to keep after the comma.","(function, type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can","pie_type == \"donut\" else False rose = True if pie_type == \"rose\" else","If set to True, the method will return the transformation used instead of","limit <= 0: limit = 0 limit = \" LIMIT {}\".format(limit) else: limit","AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4})",": maximum mean : average median : median min : minimum mode :","{})\".format(response, \"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {}","in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func","\"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\",","query = \"SELECT {}, {}({}) FROM {} GROUP BY {};\".format( by[0], fun, self.alias,","def str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn","solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {}","\" + \" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---# def ctype(self):","**style_kwds, ) # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'.","FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP","parameter is empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct","+ \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str,","\"auto\", expr: str = \"\", by: list = [], order_by: list = [],","verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax,","in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{}","query, cat = [], self.distinct() if len(cat) == 1: lp, rp = \"(\",","\"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\":","elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The","\"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\":","the partition. order_by: list, optional List of the vColumns to use to sort","optional Maximum number of points to use to evaluate the approximate density function.","self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\":","+= [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result","--------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts: str TS","/ ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH /","\"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method !=","Time Series of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn","Optimized h will be computed if the parameter is empty or invalid. max_cardinality:","float, optional Number representing the outliers threshold. Values lesser than quantile(alpha) or greater","old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn","otherwise. Returns ------- bool True if the vColumn is numerical. See Also --------","TypeError( \"cut only works on numerical / date-like vColumns.\" ) assert len(breaks) >=","h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns","file except in compliance with the License. # You may obtain a copy","on type numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False","print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun,","[ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {}","the vColumn missing values. \"\"\" if isinstance(by, str): by = [by] if isinstance(order_by,","drop_first: bool, optional Drops the first dummy to avoid the creation of correlated","/ ( sauv[\"max\"] - sauv[\"min\"] ) except: pass if method == \"robust_zscore\": self.catalog[\"median\"]","0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE","float, optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers :","record will be sliced using the floor of the slicing instead of the","False, step: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time","\\ / / / # \\ / / / # \\_______/ / /","vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool =","val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({},","will represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :","{1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \"UNION ALL","method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1] for item in query_result] index","check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start,","the approximate quantile is returned. By setting this parameter to False, the function's","transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations,","else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations]","{}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha,","Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first:","the vColumn \" \"or simply because of ambiguous columns naming.\\nBy changing one of","self, method: str = \"auto\", h: float = 0, nbins: int = -1,","Looks if some specific records are in the vDataFrame. \"\"\" if isinstance(val, str)","(6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \"\"\"","p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] +","elem[1]) for elem in result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT","self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate","[(expr, \"bool\", \"int\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\":","( \"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else:","generated. include_lowest: bool, optional If set to True, the lowest element of the","self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL(","total = self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition","range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1,","vColumn expected store usage (unit: b). Returns ------- int vColumn expected store usage.","_verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems + [str(count)]) ) query = \"SELECT","in (\"mean\", \"avg\", \"median\"): fun = \"MEDIAN\" if (method == \"median\") else \"AVG\"","vColumns used in the partition. return_trans: bool, optimal If set to True, the","------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","(\"area\", area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if","{} smallest elements.\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str","bar. If empty, an optimized h will be computed. pie_type: str, optional The","0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \"\"\"","Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\",","using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes","( \" WHERE {} IS NULL\".format(self.alias) if (category in (\"None\", None)) else \"","else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1","the optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis :","Exception as e: raise QueryError( \"{}\\nError when applying the func 'x -> {}'","odd : CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 *","# ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit:","> 0.01: h = round(h, 2) elif h > 0.0001: h = round(h,","for conducting # data science projects on data stored in Vertica, taking advantage","---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0","New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if","data when using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna","events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ())","Returns the transformation instead of the vDataFrame parent and do not apply it.","step)) # ---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element","new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the","different transformations. \"\"\" # # Special Methods # # ---# def __init__( self,","= [elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name,","[], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)]","h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \"\", h:","vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the","1] Returns ------- float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\",","for item in result], } return tablesample(values) # ---# def value_counts(self, k: int","boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return self.category()","the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}),","\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1)","Multiplies the vColumn by the input element. Parameters ---------- x: float Input number.","\"]\", \"]\" else: op1, op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if","0: offset = max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail =","If set to True, the record will be sliced using the floor of","of the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if","of nbins used for the discretization (must be > 1) Returns ------- tablesample","self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\",","features. It supports the # entire data science life cycle, uses a ‘pipeline’","= \"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS",") stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\",","optional Method to use to compute the optimal h. auto : Combination of","the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead","cube root ceil : value up to the next whole number cos :","null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and","model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name =","greater than November 1993 the 3rd. plot_median: bool, optional If set to True,","except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations","ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific","{} named {} was added to the vDataFrame.\".format( self.alias, name ) ) return","[(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\",","approximative cardinality count : number of non-missing elements cvar : conditional value at","False, the function's performance can drastically decrease. Returns ------- int vColumn cardinality (or","-------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds a","an optimized number of nbins will be computed. h: float, optional Interval width","close_r = \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r = \"<=\",","x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{}","def iloc(self, limit: int = 5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns","element density unique : cardinality (count distinct) var : variance Other aggregations could","vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif","quantile(self, x: float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by: str","new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See Also --------","\" WHERE {} IS NOT NULL \".format(self.alias) if (dropna) else \" \" result","index = [\"unique\", \"count\"] + [item[0] for item in query_result] else: result =","round(h, 6) if self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end = -1","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0]","can also be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional","\"\", cmax, cmin, ) else: final_transformation = [ ( \"({} - {}) /","[(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with","): \"\"\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used","\\ \\ \\ \\-./\\ \\ \\ \\ \\-. \\ # \\ \\__| \\","mad) minmax : Normalization using the MinMax (min and max). (x - min)","of elements to display. Returns ------- tablesample An object containing the result. For","vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if offset <","0, an optimised interval will be computed. nbins: int, optional Number of bins","merge the other into one unique category. h: float, optional The interval size","pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations +=","vColumn using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---#","parent. catalog: dict, optional Catalog where each key corresponds to an aggregation. vColumns","---# def str_replace(self, to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the","if idx == 0 and include_lowest: op1, close_l = \"<=\", \"[\" elif idx","GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if","Computes bins with the same number of elements. same_width : Computes regular width","/\\ \\ / / /\\ ___\\ /\\ __ \\ /\\ \\ /\\ \\/\\","\"\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top)",") assert len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks' must be greater","limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] =","---# def density( self, by: str = \"\", bandwidth: float = 1.0, kernel:","copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name =",") return self.parent # ---# def fillna( self, val=None, method: str = \"auto\",","use to order the data\" ) desc = \"\" if (method in (\"ffill\",","max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance).","in [\"date\", \"float\"]: warning_message = ( \"label_encode is only available for categorical variables.\"","using Random Forest.\", method=\"fetchall\", ) result = [elem[0] for elem in result] except:","/ DOQ / DOW / DOY / EPOCH / HOUR / ISODOW /","nbins: int, optional Maximum number of nbins used for the discretization (must be",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis #","distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix","self.parent.format_colnames(by) if method == \"auto\": method = \"mean\" if (self.isnum() and self.nunique(True) >","parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]: The vColumn {} was renamed '{}'.\".format(old_name, new_name) )","parameter is used for testing purpose. Returns ------- vDataFrame self.parent See Also --------","will be generated. include_lowest: bool, optional If set to True, the lowest element","= \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {} GROUP BY {};\".format( by[0],","the upper and lower outliers by their respective average. null : Replaces the","input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\"","Applies a function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def","\"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ---------- start:",": Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---#","Draws the histogram of the vColumn based on an aggregation. \"\"\" check_types( [","'{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) # ---# def spider( self, by:","self.avg() elif fun == \"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val)","Converts the vColumns to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query","int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by]","the function's performance can drastically decrease. Returns ------- float/str median See Also --------","is boolean. vDataFrame[].isdate : Returns True if the vColumn category is date. \"\"\"","/ MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND /","(Constant Interpolation). mean : Average. median : median. mode : mode (most occurent","[str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\",","for the discretization. topk : Keeps the topk most frequent categories and merge","by[0] ) result = executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for","if it is part of the DB version you are using. Returns -------","x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ----------","str, optional Numerical vColumn to use when the parameter method is set to","\"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\":","0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE","elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join(",": Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])])","in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\",","return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---#","val): self.__dict__[attr] = val # # Methods # # ---# def aad(self): \"\"\"","---------- argv: object Any amount of expressions. The expression generated will look like:","of the 'topk' method. new_category: str, optional The name of the merging category","their distributions as percents. Parameters ---------- k: int, optional Number of most occurent","consider when drawing the box plot. The other categories will be filtered. ax:","advantage Vertica’s # speed and built-in analytics and machine learning features. It supports","2\". copy_name: str, optional If not empty, a copy will be created using","vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"n\", n, [int,","vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the","vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the","missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str):","max_floor = 0 all_partition = by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]:","None ] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( cmax,","the parameter method is set to 'cat_stats'. Returns ------- tablesample An object containing",": Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the","the entire relation, a vColumn can be seen as one column of that","self.parent[y].nunique() == 2, TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) )","* i + 1] ... END odd : CASE ... WHEN vColumn =","(\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int,","by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\"",") if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE","verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h,","Parameters ---------- by: str, optional vColumn to use to partition the data. bandwidth:","start, [int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step))","self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) #","if pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from","AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias,","to the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :","Returns the n smallest elements in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])])","right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function",") ) query += [lp + tmp_query + rp] query = \"WITH vdf_table","chart. donut : Donut chart. rose : Rose chart. It can also be","to the input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{}","prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also","power of another number round : rounds a value to a specified number","vColumn type is date like). The vColumn will be transformed. Parameters ---------- field:","str, optional The vColumn to use to compute the aggregation. max_cardinality: int, optional","] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed using a","new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent,","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic","have a numerical value\" ) lower_when = ( \"WHEN {} < {} THEN","2, ParameterError( \"Parameter 'nbins' must be greater or equals to 2 in case","1 then this method will return the mode of the vColumn. Returns -------","input vColumns based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\",","optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman","item in result], } return tablesample(values) # ---# def value_counts(self, k: int =","else \"\" query, cat = [], self.distinct() if len(cat) == 1: lp, rp","except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from","\", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), )","func: str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the","response partitioned by the different vColumn categories. Parameters ---------- response: str Response vColumn.","COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_","Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies :","Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices","h will be computed if the parameter is empty or invalid. max_cardinality: int/tuple,","input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions","by an input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])])","a maximum depth of 10. response: str, optional Response vColumn when method is",") model.drop() return result except: model.drop() raise # ---# def describe( self, method:","result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT","* (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total) conj","expr = \", \".join(expr) + \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True,","func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype =","float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ----------","/ # / / # \\ / # \\ / # \\/ #","[int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) #","boolean, False otherwise. Returns ------- bool True if the vColumn is boolean. See","vColumns. bfill : Back Propagation of the next element (Constant Interpolation). ffill :","null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if","\"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned by","aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] #","check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if","optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges =","work if it is part of the DB version you are using. Returns","using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the","records. vDataFrame[].str_count : Computes the number of matches for the regular expression in","or computed) nbins: int, optional Number of bins. If empty, an optimized number","in (1, None), ValueError( \"vColumn doesn't allow slicing having steps different than 1.\"","isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns","booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\": if n == 0:","import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model =","str = \"Others\", RFmodel_params: dict = {}, response: str = \"\", return_enum_trans: bool","Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input",": Sets the method to 'numerical' if the vColumn is numerical , 'categorical'","for column in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"',",") ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem","med, mad), \"float\", \"float\", ) ] else: warning_message = \"Can not normalize {}","= self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \"\"\" ---------------------------------------------------------------------------","self.count() if (method == \"mode\") and (val == None): val = self.mode(dropna=True) if","absolute value acos : trigonometric inverse cosine asin : trigonometric inverse sine atan","] else: warning_message = \"Can not normalize {} using a Robust Z-Score -","if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20,","of expressions. The expression generated will look like: even: CASE ... WHEN vColumn","(isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\", val, [list])]) val =","\"s were \" if total > 1 else \" was \" if verticapy.options[\"print_info\"]:","optional Parent of the vColumn. One vDataFrame can have multiple children vColumns whereas","\"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn. The","---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the","max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations +=","\"''\"), value.replace(\"'\", \"''\") ) ) # ---# def str_slice(self, start: int, step: int):","= 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%',","converted to {}.\".format( self.alias, dtype ) ) return self.parent except Exception as e:","def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise.","the vColumn record by an input value. The vColumn will be transformed. Parameters","to return. Returns ------- tablesample An object containing the result. For more information,","for i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain)","are the median and two input quantiles. Parameters ---------- ts: str TS (Time","elements. same_width : Computes regular width bins. smart : Uses the Random Forest","= ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\")","sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except: pass if method == \"robust_zscore\":","to compute the Equal Frequency discretization\" ) total, query, nth_elems = nb, [],","vColumn to use when the parameter method is set to 'cat_stats'. Returns -------","in the partition. order_by: list, optional List of the vColumns to use to","category. In this case, the parameter 'numcol' must be defined. numerical : Uses","memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage.","] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) /","method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"]","\"zscore\", by: list = [], return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes","== \"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8,","\"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return parent # ---#","following mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self): \"\"\"","Cardinality threshold to use to determine if the vColumn will be considered as","self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response,","example, it can be 'minute' 'hour'... start: bool, optional If set to True,",") # ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of","def hist( self, method: str = \"density\", of: str = \"\", max_cardinality: int","the method will return the transformation used instead of the parent vDataFrame. This","------- bool True if the vColumn category is date. See Also -------- vDataFrame[].isbool","+= [elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) >",".values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6],",": Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of","normalize( self, method: str = \"zscore\", by: list = [], return_trans: bool =","max_cardinality: int = 6, numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the","prod : product range : difference between the max and the min sem","= ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count]","not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\")","= True if len(args) > 0: column = args[0] elif \"column\" in kwargs:","return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if","able to solve this \" \"issue.\" ) for k in range(len(distinct_elements) - n):","{}, \"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem in",") result[idx][1] = \"NULL\" if (elem[1] == None) else str(elem[1]) new_column = \"COALESCE({},","the filling.\".format(e)) if total > 0: try: if \"count\" in sauv: self.catalog[\"count\"] =","AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1) x","\" LIMIT {}\".format(limit) else: limit = \"\" query = \"(SELECT {} FROM {}{}","\\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql): \"\"\" ---------------------------------------------------------------------------",") result = [elem[0] for elem in result] elif self.isnum() and method in","vColumn( name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0,","the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) )","\"Parameter 'k' must be greater or equals to 2 in case of discretization","(\"ffill\", \"pad\")) else \" DESC\" partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column)","or equal to 1\") where = \" WHERE {} IS NOT NULL \".format(self.alias)","bool = False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most","def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element.","\"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\".format( self.alias.replace('\"',","self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__(","100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem in sauv: if \"top\" in","method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\",","\", \".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\",","memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory","\"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\": {}, \"regr_sxx\":","ParameterError( \"Length of parameter breaks must be equal to the length of parameter","not (h) or h <= 0: if nbins <= 0: h = self.numh()","the vColumn. The function variable must be composed of two flower brackets {}.",") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self,","of seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent See","{\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str):","self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item","result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN","int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ----------","[list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns =","optional The name of the merging category when using the 'topk' method. RFmodel_params:","= -1 if (self.category() == \"int\") else \"\" if (h > 1) or","Bar Chart of vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method,","column = [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem =","OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query,","{} {} missing value{} filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]:","vColumn {} was converted to {}.\".format( self.alias, dtype ) ) return self.parent except","check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns = [ column for column","the vColumn is null, 1 otherwise. expr: str, optional SQL expression. by: list,","self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str = \"density\",","global outlier). \"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\",",")[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {} AS ord, {}::int AS","\"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max,","\"vColumn doesn't allow slicing having steps different than 1.\" ) index_stop = index.stop","self.alias ), method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha = \"NULL\" if","empty.\" ) conditions, column = [], self.alias for idx in range(len(breaks) - 1):","[ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\".format(","from the vColumn. Parameters ---------- x: float If the vColumn type is date",") assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \"Length of","Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM","of the vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular","WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT","lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame","(ex: 50% for the median) prod : product range : difference between the","( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\",","if isinstance(method, str): method = method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]),","(isinstance(lower, (float, int))) else \"\" ) upper_when = ( \"WHEN {} > {}","float]), (\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from","the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {},","stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({})","input element to the vColumn. Parameters ---------- x: float If the vColumn type","\"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\",","self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The","= ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \"categorical\"):","---------- alias, str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations.","BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query","nth_elems += [str(total)] total += nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \",","expected store usage (unit: b). Returns ------- int vColumn expected store usage. See","used to compute the best splits when 'method' is set to 'smart'. A","input vColumns using the input method. Parameters ---------- method: str, optional Method to","new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column = \"DECODE({}, NULL,","mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0: if","solve this \" \"issue.\" ) for k in range(len(distinct_elements) - n): name =","vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies a function","range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg =","-------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes","FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the descriptive","mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if","will memorize the already computed aggregations to gain in performance. The catalog will","purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame","some specific records are in the vColumn and it returns the new vDataFrame","'smart'.\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import (","for the discretization (must be > 1) Returns ------- tablesample An object containing","\\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # #","if the vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical","BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC","Licensed under the Apache License, Version 2.0 (the \"License\"); # You may not","be transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str, optional","{}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\".format( alpha,","If empty, an optimized number of nbins will be computed. h: float, optional","being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest","OVER ({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in","each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace,","AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query,","self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def","mad), \"float\", \"float\", ) ] else: warning_message = \"Can not normalize {} using","variance Other aggregations could work if it is part of the DB version","changing the parameter 'name', you'll be able to solve this issue.\" ) new_vColumn","only the input number of digits after the comma. Parameters ---------- n: int","of: str, optional The vColumn to use to compute the aggregation. max_cardinality: int,","\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\".format(","= self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL(","November 1993 the 3rd. area: bool, optional If set to True, draw an","or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also","copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ]","\"mode\") and (val == None): val = self.mode(dropna=True) if val == None: warning_message","the k most occurent elements and their distributions as percents. Parameters ---------- k:","# __ __ ______ ______ __ __ __ __ __ __ __ #","\"backfill\"]: all_partition += [elem for elem in order_by] for elem in all_partition: if","\"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---#","values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str =","return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---# def","self.alias, ) else: query = \"SELECT {} FROM (SELECT {} AS {}, {}","comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function","date like). The vColumn will be transformed. Parameters ---------- field: str The field","1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, )","Propagation of the first element (Constant Interpolation). mean : Average. median : median.","True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule.","threshold to use to determine if the vColumn will be considered as categorical.","Number of elements to display. Returns ------- tablesample An object containing the result.","[str(total)] total += nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] +","total > 0: try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total","self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold *",") else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans = (\"{}",": trigonometric inverse tangent cbrt : cube root ceil : value up to","+ result + [self.max()] elif method == \"topk\": assert k >= 2, ParameterError(","the vColumn using a bijection from the different categories to [0, n -","(c) Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed under","Forest with 20 trees and a maximum depth of 10. response: str, optional","): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if","the vColumn is boolean, False otherwise. Returns ------- bool True if the vColumn","the computation. Returns ------- tablesample An object containing the result. For more information,","str = \"\", bandwidth: float = 1.0, kernel: str = \"gaussian\", nbins: int","is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method ==","include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \"cut","Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar Chart of","0: try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] =","the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate :","like (date, datetime ...), the parameter 'x' will represent the number of seconds,","other types to varchar. same_freq : Computes bins with the same number of","FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_","{} using a Robust Z-Score - The MAD is null !\".format( self.alias )","risk dtype : vColumn type iqr : interquartile range kurtosis : kurtosis jb","if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError(","( ((distinct_count < max_cardinality + 1) and (method != \"numerical\")) or not (is_numeric)","the quantile. For example: 0.25 represents Q1. approx: bool, optional If set to","executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias,","if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem in","vColumn. The category will be one of the following: date / int /","+= [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\" ---------------------------------------------------------------------------","query = \"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table","threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns","{} WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ),","in (\"float\", \"int\") # ---# def iv_woe(self, y: str, nbins: int = 10):","using the MIN and the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message,","the vColumn category is date. \"\"\" return self.category() in (\"float\", \"int\") # ---#","{})\".format(\"{}\", start, step)) # ---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the","end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates","vColumns simplify several processes with its abstractions. Parameters ---------- alias: str vColumn alias.","or (numcol), ParameterError( \"The parameter 'numcol' must be a vDataFrame column if the","the vColumn using the mean encoding of a response. \"\"\" import verticapy.stats as","|| ';' || (FLOOR({} / {}) * {} + {}{}) || ']'\".format( \"{}\",","\"column\" in kwargs: column = kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column)","in each record of the vColumn. The vColumn will be transformed. Parameters ----------","response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn {} must be binary to","upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional","median) prod : product range : difference between the max and the min","transformation instead of the vDataFrame parent and do not apply it. This parameter","model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING","isinstance(by, str): by = [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\",","0 and include_lowest: op1, close_l = \"<=\", \"[\" elif idx == 0: op1,","# ---# def apply_fun(self, func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies","\"mean\", \"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\",","self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the","approx: bool, optional If set to True, the approximate cardinality is returned. By","if distinct_count > max_cardinality: query += ( \"UNION ALL (SELECT 'Others', SUM(count) FROM","Union # VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import",") # ---# def plot( self, ts: str, by: str = \"\", start_date:","data around for processing, VerticaPy brings the logic to the data. # #","Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by, str):","{} to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0],","optional The vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum","str = \"zscore\", by: list = [], return_trans: bool = False ): \"\"\"","== 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT {}, AVG({}),","aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters",": Replaces the regular expression matches in each of the vColumn records by","= {\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density(","len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin,","RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\": 20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters","(avg and std). (x - avg) / std robust_zscore : Normalization using the","max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd =","round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input","gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman","argv[2 * i] THEN argv[2 * i + 1] ... END odd :","vDataFrame. Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame self.parent","elif method == \"mean\": query = \"WITH vdf_table AS (SELECT * FROM {})","\"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if","nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {}","be used as categorical (No h will be picked or computed) nbins: int,","------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","== \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"]","occurent element density unique : cardinality (count distinct) var : variance Other aggregations","1 and 2 to be used as categorical (No h will be picked","by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of:",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std #","of the vColumn records by an input value. \"\"\" check_types([(\"start\", start, [int, float]),","AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias,","\" result = executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM","at the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :","\"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\": assert nbins","expression is in each of the vColumn records. The vColumn will be transformed.","hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent tanh :","date / int / float / text / binary / spatial / uuid","total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum).","of the vColumn 'of'. max : Maximum of the vColumn 'of'. sum :","a vColumn means simply not selecting it in the final generated SQL code.","USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =","\\'/ \\ \\ \\____ \\ \\ \\/\\ \\ \\ \\ \\____ \\ \\","skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See","using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---# def tail(self, limit:","in (\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, )","Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the","{}\".format(k) dropna = \" WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else \"\"","in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice):","float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---#","bins used for the discretization (must be > 1) k: int, optional The","+= [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was","= \"\", max_cardinality: int = 6, nbins: int = 0, h: float =","(response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] +=","---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding.","self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to {}.\".format( self.alias, dtype ) )","topk most frequent categories and merge the other into one unique category. h:","self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self,","when first preparing your data. Parameters ---------- new_name: str The new vColumn alias.",") for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2]","def quantile(self, x: float, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING","WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha,","NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str = \"winsorize\",","with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to","of the vColumn records. The vColumn will be transformed. Parameters ---------- pat: str","self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ),","not be empty in case of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response)",") # ---# def apply_fun(self, func: str, x: float = 2): \"\"\" ---------------------------------------------------------------------------","NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str = \"winsorize\", threshold:","vDataFrame[].str_count : Computes the number of matches for the regular expression in each","# # Modules # # Standard Python Modules import math, re, decimal, warnings,","|| ']'\".format( \"{}\", h, h, \"{}\", h, h, h, floor_end ), \"varchar\", \"text\",","<= 0: limit = 0 limit = \" LIMIT {}\".format(limit) else: limit =",": Adds a new vColumn to the vDataFrame by using an advanced analytical","conj = \"s were \" if len(all_new_features) > 1 else \" was \"","0: nullifzero = 0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin","new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :","to convert to use to convert the vColumn. If this parameter is equal","a numerical column for each vColumn category. In this case, the parameter 'numcol'","p_1_alpha) ) return self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame","\"\" ) order_by_ts = \", \".join([quote_ident(column) + desc for column in order_by]) new_column","/ {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin,","time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv):","------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram","from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)","x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts the","0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn","plot of the vColumn. The aggregations used are the median and two input","def bar( self, method: str = \"density\", of: str = \"\", max_cardinality: int","\"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 *",") query = \"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events,","True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool,","type date like. Optimized h will be computed if the parameter is empty","the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes","--------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also","= 5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part of the","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest","str): by = [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by,","pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str : List","Uses numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent","pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(),","self.alias, len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode =",": most occurent element percent : percent of non-missing elements q% : q","\", \".join(by) ), ) if return_trans: return \"({} - {}) / {}({} -","* result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query =","n: int, optional Integer corresponding to the offset. For example, if n =","to the vDataFrame.\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self,","'\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name =","MinMax (min and max). (x - min) / (max - min) by: list,","= \" LIMIT {}\".format(limit) else: limit = \"\" query = \"(SELECT {} FROM","also be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The","( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was","val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns","- n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"',","prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct()","largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature","BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format(","\" \" result = executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_","\"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]),","data stored in Vertica, taking advantage Vertica’s # speed and built-in analytics and","method on the vColumn \" \"or simply because of ambiguous columns naming.\\nBy changing","vDataFrame.iv_woe : Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\",","evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn","max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h),","self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(","/ date, optional Input End Date. For example, time = '03-11-1993' will filter","of the {}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if","to use to sort the data when using TS methods. Returns ------- vDataFrame","-= len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations +=",") return self.parent # ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct","), ) executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False,","AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or","-1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements","response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response","to 1\") where = \" WHERE {} IS NOT NULL \".format(self.alias) if (dropna)","self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val):","\\/_/ # # # ---# class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that","--------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average See Also","data. Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent","return tablesample(values) # ---# def value_counts(self, k: int = 30): \"\"\" --------------------------------------------------------------------------- Returns","MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing","\"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY","\"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations += [trans] sauv = {}","total = abs(self.count() - total) except Exception as e: self.transformations = [elem for","is very useful for testing to be able to look at the final","slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent See Also","the vColumns to use to sort the data when using TS methods. Returns","self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\"Different aggregations to compute","fill the vColumn outliers. mean : Replaces the upper and lower outliers by","\"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL GROUP BY","elif self.isnum(): if method == \"zscore\": if n == 0: nullifzero = 0","datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)","the NULL value. winsorize : Clips the vColumn using as lower bound quantile(alpha)","kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D(","conj, \", \".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode = get_dummies #","The axes to plot on. **style_kwds Any optional parameter to pass to the","and method in (\"same_width\", \"auto\"): if not (h) or h <= 0: if","rose : Rose chart. It can also be a cutomized aggregation (ex: AVG(column1)","\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of","by elements, please use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad,","vColumn {} was renamed '{}'.\".format(old_name, new_name) ) return parent # ---# def round(self,","\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__()","schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema, name=\"view\") tmp_model_name = gen_tmp_name(schema=schema, name=\"model\") assert nbins","draw the Plot. start_date: str / date, optional Input Start Date. For example,","self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by","range plot of the vColumn. The aggregations used are the median and two","sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for","or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to be","ax=ax, **style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the","(\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ), (","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0]","\"_\") + prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first else 0 for","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based","the specified name. \\u26A0 Warning : SQL code generation will be slower if","using. Returns ------- tablesample An object containing the result. For more information, see","FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha =","column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines","--------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list Distinct caterogies","# \\ / _ __|_. _ _ |_) # \\/ (/_| | |(_(_||","to use to order the data. The vColumn type must be date like","else result[0][0] if not (dropna): n = \"\" if (n == 1) else","from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin = self.min()","a function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self,","self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT {}, MIN(ord) AS ord, SUM(1","count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], )","{}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"]","else \"\", cmax, cmin, ), \"float\", \"float\", ) ] if method != \"robust_zscore\":","return self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in by]) )","elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method ==","if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", ) ] if method","return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method == \"smart\":","number of vColumn distinct elements to be used as categorical. The less frequent","\"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and","Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to","check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]),",": difference between the max and the min sem : standard error of","!\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique()","MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n ==","--------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE) Table. It","use_threshold: bool = True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the","the vColumn will be considered as categorical. numcol: str, optional Numerical vColumn to","This parameter is very useful for testing to be able to look at","the mean encoding of a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\",","to use this method when first preparing your data. Parameters ---------- new_name: str","+= [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend(","the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also --------","{}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL(","ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias,","((is_date) and not (method == \"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\":","/ float / text / binary / spatial / uuid / undefined Returns","\"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name:","if (isinstance(upper, (float, int))) else \"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when,",": Average. median : median. mode : mode (most occurent element). 0ifnull :","each record of the vColumn. The vColumn will be transformed. Parameters ---------- pat:","vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\",","\"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else: final_transformation = [ ( \"({}","(SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION","the median) prod : product range : difference between the max and the","default function to the vColumn. Parameters ---------- func: str Function to use to","of the vColumn. Parameters ---------- by: str, optional vColumn to use to partition","generated SQL code. Note: Dropping a vColumn can make the vDataFrame \"heavier\" if","+= sys.getsizeof(elem) return total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str =","self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\" if","by: str, optional vColumn to use to partition the TS. start_date: str /","by using an advanced analytical function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func,","Number of most occurent elements to return. Returns ------- tablesample An object containing","to 2 in case of discretization using the method 'smart'.\" ) assert response,","if method == \"zscore\": if n == 0: nullifzero = 0 avg, stddev","the vColumn is numerical or of type date like. Optimized h will be","vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks: list,","p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method","Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))])","tablesample An object containing the result. For more information, see utilities.tablesample. See Also","filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in","self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return \"({}","in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem in order_by] for","datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles used","/ {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min,","= 5): \"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit:","bool True if the vColumn category is date. See Also -------- vDataFrame[].isbool :","\".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else:","assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not be empty\" ) assert","self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias, conj, ) ) else:","copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by","index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int):","!= None ] ), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join(","!= 0: if return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad) else:","result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise","(/_| | |(_(_|| \\/ # / # VerticaPy is a Python library with","List of the vColumns to use to sort the data when using TS","also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object,","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the","the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ]","cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import","of 10. response: str, optional Response vColumn when method is set to 'smart'.","element from the vColumn. Parameters ---------- x: float If the vColumn type is","occurent elements to return. Returns ------- tablesample An object containing the result. For","query, ) query = \"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER","vColumn type is date like (date, datetime ...), the parameter 'x' will represent","method == \"smart\" ): n = len(result) trans = \"(CASE \" for i","if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return","new vColumn to the vDataFrame by using an advanced analytical function on a","elif isinstance(index, int): cast = \"::float\" if self.category() == \"float\" else \"\" if","data. count : Number of elements. density : Percentage of the distribution. mean","method 'same_width' for numerical vColumns, cast the other types to varchar. same_freq :","(method == \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in","self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message =","\"''\")) if elem[0] != None else \"NULL\", elem[2] if elem[2] != None else","self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn {} named","--------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std See","(\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__(","isinstance(val, float): category, ctype = \"float\", \"float\" elif method == \"0ifnull\": category, ctype","of digits after the comma. Parameters ---------- n: int Number of digits to","of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist( self, method: str","FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return","OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans: return \"({}","Adds a new vColumn to the vDataFrame by using an advanced analytical function","datetime ...), the parameter 'x' will represent the number of seconds, otherwise it","\"\"\" if isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])])","---------- x: float A float between 0 and 1 that represents the quantile.",") title = \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) #","str, optional The vColumn to use to compute the aggregation. h: int/float/tuple, optional","( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION","/ QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK",": Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice :","({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile","( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) assert","transformations: list = [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations","1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {}","the above. The idea is simple: instead of moving # data around for","0: warning_message = \"Can not normalize {} using a Z-Score - The Standard","index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0:","\"\" if (method in (\"ffill\", \"pad\")) else \" DESC\" partition_by = ( \"PARTITION","partition_by, order_by_ts ) if method in (\"mean\", \"median\") or isinstance(val, float): category, ctype","n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp","right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \"cut only works on","max : Maximum of the vColumn 'of'. sum : Sum of the vColumn","**style_kwds) # ---# def category(self): \"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn.","THEN '{label}'\" ] expr = \"CASE WHEN \" + \" WHEN \".join(conditions) +","Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn","\"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr)","where = \" WHERE {} IS NOT NULL \".format(self.alias) if (dropna) else \"","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---#","self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format(","in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\",","= catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in","the Robust Z-Score (median and mad). (x - median) / (1.4826 * mad)","/ / # |______ / / / # |____/ / / # _____________","Normalization\") return self.parent # ---# def nsmallest(self, n: int = 10): \"\"\" ---------------------------------------------------------------------------","elem[1] != None ] ), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0], \",","closed on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :","utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\",","\"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias","1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", )","n ), title=\"Computing the mode.\", method=\"fetchall\", ) top = None if not (result)","Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also --------","== None): val = self.mode(dropna=True) if val == None: warning_message = \"The vColumn","\"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else:","order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---#","limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {} FROM","if (nullifzero) else \"\", stddev ) else: final_transformation = [ ( \"({} -","1 or not (labels), ParameterError( \"Length of parameter breaks must be equal to","based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]),",": Encodes the vColumn using the mean encoding of a response. \"\"\" if","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing","or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\",","the vColumn. \"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if offset","SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns","if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(),","__ __ __ __ __ __ # /\\ \\ / / /\\ ___\\","return parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool","ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with","transformed with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) )","END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates","Method to use to compute the optimal h. auto : Combination of Freedman","FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query,","name the new categories. If empty, names will be generated. include_lowest: bool, optional","lesser than the lower bound to the lower bound itself and the values","to the vColumn. Parameters ---------- x: float If the vColumn type is date","values = { \"index\": [item[0] for item in result], \"count\": [int(item[1]) for item","= [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if","depth of 10. response: str, optional Response vColumn when method is set to","or self.isdate(), TypeError( \"cut only works on numerical / date-like vColumns.\" ) assert","greater or equals to 2 in case of discretization using the method 'same_freq'\"","to transform the vColumn. The function variable must be composed of two flower","**kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list","{}) * {} || ';' || (FLOOR({} / {}) * {} + {}{})","Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns,","max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1 and 2","0: h = self.numh() else: h = (self.max() - self.min()) * 1.01 /","to compute other vColumns. Parameters ---------- add_history: bool, optional If set to True,","ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in (\"mean\", \"median\")","name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj","expression. by: list, optional vColumns used in the partition. order_by: list, optional List","add(self, x: float): \"\"\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters","END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations +=","--------------------------------------------------------------------------- Python object which that stores all user transformations. If the vDataFrame represents","= executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem in","int/float/str, optional Value to use to impute the vColumn. method: dict, optional Method","of the vColumns to use to sort the data when using TS methods.","set to True, the approximate quantile is returned. By setting this parameter to","self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", )","---# def boxplot( self, by: str = \"\", h: float = 0, max_cardinality:","the Bar Chart of vColumn based on an aggregation. \"\"\" check_types( [ (\"method\",","\"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} <","a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate():","elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index,","compute the best splits when 'method' is set to 'smart'. A RF Regressor","self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can not normalize {} using","independent variable in relation to the dependent variable. Parameters ---------- y: str Response","k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr = \", \".join(expr) +","expression matches in each of the vColumn records by an input value. \"\"\"","int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *=","[ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\",","\"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method == \"mean\": query = \"WITH","\"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) )","Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies","vColumn using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate :","using a bijection from the different categories to [0, n - 1] (n","END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new","(\"legend\" in kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in kwargs): kwargs[\"figsize\"] =","\"\"\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn record","APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS",": Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with","[ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response,","self.parent See Also -------- vDataFrame.filter: Filters the data using the input expression. \"\"\"","= ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) )","False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\"","head of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \"\"\"","vColumn using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate :","( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table","# ---# def tail(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the tail","--------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an aggregation. Parameters","by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h,","copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for k in range(max_floor): self.transformations +=","\"\"\" return self.category() == \"date\" # ---# def isin(self, val: list, *args): \"\"\"","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on","mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\"",".replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\",","absolute value function to the input vColumn. Returns ------- vDataFrame self.parent See Also","of the vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex:","table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias,","method = method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp","[list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert","3.0), 1e-99) if method.lower() == \"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\",","utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the","20, \"max_depth\": 10} to train a Random Forest with 20 trees and a","the Time Series of the vColumn. Parameters ---------- ts: str TS (Time Series)","{ \"index\": [\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result, } if","FROM {} WHERE {} IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(),","= 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn","name, parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\":",": Draws the Bar Chart of the input vColumns based on an aggregation.","# \\/ (/_| | |(_(_|| \\/ # / # VerticaPy is a Python","is used to compute other vColumns. Parameters ---------- add_history: bool, optional If set","return total # ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min'","[int, float]), (\"dropna\", dropna, [bool])]) topk = \"\" if (k < 1) else","'', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format(","trigonometric inverse tangent cbrt : cube root ceil : value up to the","verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1) x ORDER","IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(),","str = \"\", return_enum_trans: bool = False, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn","auto : Sets the method to 'numerical' if the vColumn is numerical ,","ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self):","vDataFrame[].head : Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) #","def memory_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn","|| (FLOOR({} / {}) * {} + {}{}) || ']'\".format( \"{}\", h, h,","+ by) by = self.parent.format_colnames(by) if method == \"auto\": method = \"mean\" if","the response partitioned by the different vColumn categories. Parameters ---------- response: str Response","sum : sum std : standard deviation topk : kth most occurent element","AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\".format( self.alias, dtype,","method == \"same_freq\") or ( self.isnum() and method == \"smart\" ): n =","len(result) trans = \"(CASE \" for i in range(1, n): trans += \"WHEN","\"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold","the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to","END AS iv FROM ({}) x ORDER BY ord\".format( self.alias, query, ) title","Maximum of the vColumn 'of'. sum : Sum of the vColumn 'of'. q%","xlim: tuple, optional Set the x limits of the current axes. ax: Matplotlib","* (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower()","has already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll be able to","of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return","aggregate # ---# def apply(self, func: str, copy_name: str = \"\"): \"\"\" ---------------------------------------------------------------------------","---# def bar( self, method: str = \"density\", of: str = \"\", max_cardinality:","order_by_ts ) if method in (\"mean\", \"median\") or isinstance(val, float): category, ctype =","drop_first else 0 for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix,",": Sum of the vColumn 'of'. q% : q Quantile of the vColumn","the vColumn using the input list. Parameters ---------- breaks: list List of values","'ts' is greater than November 1993 the 3rd. plot_median: bool, optional If set","1], TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans","decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str","self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str","greater than the threshold, it will be considered as an outlier. use_threshold: bool,","isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [","self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted","from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not","{} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method ==","(\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not","pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or","For example, time = '03-11-1993' will filter the data when 'ts' is lesser","ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \"\",","else: h = (self.max() - self.min()) * 1.01 / nbins if h >","of the vDataFrame parent and do not apply it. This parameter is very","Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to","the best splits when 'method' is set to 'smart'. A RF Regressor will","input type. \"\"\" check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{} AS {}","elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif method","str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations:","The catalog will be updated when the parent vDataFrame is modified. Attributes ----------","\"''\")) ) # ---# def str_replace(self, to_replace: str, value: str = \"\"): \"\"\"","transformation used instead of the parent vDataFrame. This parameter is used for testing","License, Version 2.0 (the \"License\"); # You may not use this file except","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate :","# / __ `\\ / / # | \\/ / / / #","): query = \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0}","of elements to skip. Returns ------- tablesample An object containing the result. For","same number of elements. same_width : Computes regular width bins. smart : Uses","/\\ __ \\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\ \"-.\\","verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model","area, step, ax=ax, **style_kwds, ) # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","/ MINUTE / MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR","science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations,","method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif","[bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\", nbins, [int, float]), (","category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple","floor_end ), \"varchar\", \"text\", ) else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\")",": Propagation of the first element (Constant Interpolation). mean : Average. median :","{}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---#","BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method in (\"ffill\", \"pad\",","# Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc import","breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] )","function's performance can drastically decrease. Returns ------- float quantile (or approximate quantile). See","Series) vColumn to use to order the data. The vColumn type must be","was normalized with the method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The","), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {}","tail of the vColumn. Parameters ---------- limit: int, optional Number of elements to","\"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix:","(quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor =","warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\": if n == 0: nullifzero","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" ---------------------------------------------------------------------------","performance. The catalog will be updated when the parent vDataFrame is modified. Attributes","---# def fillna( self, val=None, method: str = \"auto\", expr: str = \"\",","if the vColumn will be considered as categorical. numcol: str, optional Numerical vColumn","bool = False, step: bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1","= self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax,","optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] ) method","with the License. # You may obtain a copy of the License at","in pure SQL used to transform the vColumn. The function variable must be","response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return self.parent","vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn","\"-.\\ \\ # \\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\","self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1","\"freedman_diaconis\", \"fd\", \"auto\"])] ) method = method.lower() if method == \"auto\": pre_comp =","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with","+= [trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,","---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing","statics of {} partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values","the category of the vColumn. The category will be one of the following:","0, Exception( \"Not enough values to compute the Equal Frequency discretization\" ) total,","func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for k","gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in kwargs): from verticapy.plot import","elem[0] != None else \"NULL\", elem[2] if elem[2] != None else \"NULL\", )","self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of,","/ SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR","warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if n == 0: nullifzero","was filled.\") self.transformations = [elem for elem in copy_trans] for elem in sauv:","where, ) result = executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\",","index < 0: index += self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET","vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types( [ (\"breaks\",","tuple] = (None, None), ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the spider plot","See Also -------- vDataFrame[].str_count : Computes the number of matches for the regular","law or agreed to in writing, software # distributed under the License is","will also increase the time of the learning and scoring phases. xlim: tuple,","float, optional Uses the Gaussian distribution to define the outliers. After normalizing the","apply(self, func: str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to",": Looks if some specific records are in the vDataFrame. \"\"\" if isinstance(val,","READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i","It can also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib","vColumns to use to sort the data when using TS methods. Returns -------","= 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\".format(","utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail","float]), (\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)","Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns ------- int number","import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def","{}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to normalize.\",","raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result + [self.max()] elif","Methods # # ---# def __init__( self, alias: str, transformations: list = [],","{} THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i - 1], result[i]","values to compute the Equal Frequency discretization\" ) total, query, nth_elems = nb,","in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0]","== \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name =","return self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the","if the vColumn category is date. \"\"\" return self.category() in (\"float\", \"int\") #","vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.","+ tmp_query + rp] query = \"WITH vdf_table AS (SELECT * FROM {})","largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An","'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame","unit: str, optional Slice size unit. For example, it can be 'minute' 'hour'...","\"max\", ] if method != \"cat_stats\": values = { \"index\": [\"name\", \"dtype\"] +","Slice size unit. For example, it can be 'minute' 'hour'... start: bool, optional","elem in result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias),","DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins -","\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE","isinstance(func, str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try:","check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]),","BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {}","mean encoding of a response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv))","1993 the 3rd. area: bool, optional If set to True, draw an Area","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def","column to find the most relevant interval to use for the discretization. topk","category. h: float, optional The interval size to convert to use to convert","+= [sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","or h <= 0: if nbins <= 0: h = self.numh() else: h","2.0 (the \"License\"); # You may not use this file except in compliance","of the following: CENTURY / DAY / DECADE / DOQ / DOW /","return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'.","input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See","---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] =","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist :","if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0]","a function to the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({},","the mean skewness : skewness sum : sum std : standard deviation topk","the head of the vColumn. Parameters ---------- limit: int, optional Number of elements","by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D","method used for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel.","(\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type,","\"AVG\" if by == []: if fun == \"AVG\": val = self.avg() elif","aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if n == 1:","be date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to","same_freq : Computes bins with the same number of elements. same_width : Computes","dropna, self.alias, topk, ) result = executeSQL( query, title=\"Computing the top{} categories of","[ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method","[int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] )","cmax = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\"))","it returns the new vDataFrame of the search. Parameters ---------- val: list List","1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing","== None: mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply(","NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype","result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\") and (numcol != \"\"): numcol","warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method","] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return","method == \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater","by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date,","Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total > 0: try: if \"count\"","# ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error","self.parent except Exception as e: raise ConversionError( \"{}\\nThe vColumn {} can not be","# ---# def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category is","self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\"Computing the equal frequency histogram","self.isdate(), ParameterError( \"numh is only available on type numeric|date\" ) if self.isnum(): result","train a Random Forest with 20 trees and a maximum depth of 10.","percent : percent of non-missing elements q% : q quantile (ex: 50% for","= 0 self.catalog[\"mad\"] = 1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] =","missing values. \"\"\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by","was converted to {}.\".format( self.alias, dtype ) ) return self.parent except Exception as","'of'. max : Maximum of the vColumn 'of'. sum : Sum of the","the bar. If empty, an optimized h will be computed. ax: Matplotlib axes","( \"label_encode is only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements","vColumn using a time series rule. Parameters ---------- length: int Slice size. unit:","used as categorical (No h will be picked or computed) ax: Matplotlib axes","/ DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR /","dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \"[AsType]: The vColumn {} was converted to","= [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e))","Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]}","0 ] # ---# def range_plot( self, ts: str, q: tuple = (0.25,","-------- vDataFrame.topk : Returns the vColumn most occurent elements. \"\"\" if \"agg\" not","input list. Parameters ---------- breaks: list List of values used to cut the","else: final_transformation = [ ( \"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\"","type. \"\"\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips","Parameters ---------- method: str, optional The method to use to discretize the vColumn.","vColumn has already the alias {name}.\\nBy changing the parameter 'name', you'll be able","self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"] = 1","for elem in sauv: if \"top\" in elem: if \"percent\" in elem: self.catalog[elem]","element of the list will be included. right: bool, optional How the intervals","Number representing the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha)","query, ) query = \"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE","self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return self.parent # ---# def","for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes","== \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE","date like (date, datetime ...), the parameter 'x' will represent the number of","inverse sine atan : trigonometric inverse tangent cbrt : cube root ceil :","cardinality is returned. By setting this parameter to False, the function's performance can","\"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\",","attr, val): self.__dict__[attr] = val # # Methods # # ---# def aad(self):","\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,","== None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {}","(\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by]","to impute the missing values. auto : Mean for the numerical and Mode","\"\"\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog)","+ result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({})","Also -------- vDataFrame[].str_count : Computes the number of matches for the regular expression","self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else: final_transformation = [","self.alias: [best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h), 1) return best_h #","Exception( \"Not enough values to compute the Equal Frequency discretization\" ) total, query,","using the input method. Parameters ---------- method: str, optional Method to use to",": Returns the n smallest elements in the vColumn. \"\"\" check_types([(\"n\", n, [int,","function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object","--------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns ------- int","(1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal","will not be considered during the computation. Returns ------- tablesample An object containing","of type date like. Optimized h will be computed if the parameter is","is date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return","expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations","---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the","to the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional","WHEN non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events /","want to normalize by grouping by elements, please use a method in zscore|minmax\"","import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#","with scikit-like functionality for conducting # data science projects on data stored in","of elements to display. offset: int, optional Number of elements to skip. Returns","method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\":","use to impute the missing values. auto : Mean for the numerical and","THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv","The MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method","of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of","\"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\": assert nbins >= 2,","int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN ({}) THEN {}","(\"response\", response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\",","{ \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {},","self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0]",") return parent # ---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the","str): method = method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha,","of the response partitioned by the different vColumn categories. Parameters ---------- response: str","have one parent. catalog: dict, optional Catalog where each key corresponds to an","logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins:","\"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s were \"","is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return","median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","the pie chart of the vColumn based on an aggregation. Parameters ---------- method:","to normalize.\".format( by[0] ), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0], \",","-------- vDataFrame[].str_count : Computes the number of matches for the regular expression in","using a mean encoding with {} as Response Column.\".format( self.alias, response ) )","h, \"{}\", h, h, h, floor_end ), \"varchar\", \"text\", ) else: trans =","\"NULL\", ) for elem in result if elem[2] != None ] ), )","second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r =","vColumn can be seen as one column of that relation. vColumns simplify several","to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] +=","(median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes","self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]","0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events","== \"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype = self.category(), self.ctype()","in case of discretization using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans","int, optional Number of elements to display. Returns ------- tablesample An object containing","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of",") for elem in result if elem[2] != None ] ), ) executeSQL(","size. unit: str, optional Slice size unit. For example, it can be 'minute'","if (by) else \"\" ) order_by_ts = \", \".join([quote_ident(column) + desc for column","the distinct categories of the vColumn. Returns ------- list Distinct caterogies of the","to the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also --------","\"\"\" check_types([(\"start\", start, [int, float]), (\"step\", step, [int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\",","Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types(",": Uses only categorical aggregations during the computation. cat_stats : Computes statistics of","= \"\" if (method in (\"ffill\", \"pad\")) else \" DESC\" partition_by = (","**kwargs) # ---# def get_dummies( self, prefix: str = \"\", prefix_sep: str =","of non-missing elements cvar : conditional value at risk dtype : vColumn type","y) result = to_tablesample(query, title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] +=","try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({})","k: int = -1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the k","input vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority]","this file except in compliance with the License. # You may obtain a","vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.","(1.0 / 3.0), 1e-99) if method.lower() == \"sturges\": best_h = sturges elif method.lower()","bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time","elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h = max(sturges, fd)","a specific TS field from the vColumn (only if the vColumn type is","\"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result, } if ((is_date) and not","jb : Jarque-Bera index mad : median absolute deviation max : maximum mean","or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\")","vColumn will be transformed. Parameters ---------- start: int Start of the slicing. step:","greater than November 1993 the 3rd. area: bool, optional If set to True,","numerical. \"\"\" return self.category() == \"date\" # ---# def isin(self, val: list, *args):","'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max","float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","the Bar Chart of the input vColumns based on an aggregation. \"\"\" check_types(","k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER","bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\":","GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias,","+ result index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\",","**style_kwds ) model.drop() return result except: model.drop() raise # ---# def describe( self,","= \", \".join([quote_ident(column) + desc for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({}","cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1})","\\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ # # # ---# class vColumn(str_sql): \"\"\"","def nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique'","not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias {name}.\\nBy changing the parameter","when the vColumn is null, 1 otherwise. expr: str, optional SQL expression. by:","verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None,","\"issue.\" ) for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k)","List of the different transformations. Each transformation must be similar to the following:","vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the","AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN \" +","hot encoder was applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj,","Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","use to order the data. The vColumn type must be date like (date,","each of the vColumn records. vDataFrame[].str_count : Computes the number of matches for","the input element to the vColumn. Parameters ---------- x: float If the vColumn","response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must","= max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99)","--------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise. Returns -------","elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif method in","check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\",","under the License. # # |_ |~) _ _| _ /~\\ _ |.","elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\")",": trigonometric cotangent exp : exponential function floor : value down to the","alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha)","vColumn to use to partition the TS. start_date: str / date, optional Input","\"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]),","[ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr","used to compute other vColumns. Parameters ---------- add_history: bool, optional If set to","occurent element). 0ifnull : 0 when the vColumn is null, 1 otherwise. expr:","doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \"zscore\": if","\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\".format( self.alias, method )","MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING","import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, )","= 6, numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func:","**style_kwds, ) # ---# def plot( self, ts: str, by: str = \"\",","self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x)) #","See Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by","--------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ---------- method: str,","index += self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format(","Number of nbins. If empty, an optimized number of nbins will be computed.","will be trained if the response is numerical (except ints and bools), a","WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices","dummies ({name}).\\n\" \"It can be the result of using previously the method on","interval to use for the discretization. topk : Keeps the topk most frequent","self.isnum() and method == \"smart\" ): n = len(result) trans = \"(CASE \"","( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \"categorical\"): result","return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the","when drawing the box plot. The other categories will be filtered. ax: Matplotlib","query_result = executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", ) return","field from the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\", unit,","self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]","\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN","Applies a function to the input vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]),","verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name","False rose = True if pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of)","= \"Computing WOE & IV of {} (response = {}).\".format(self.alias, y) result =","[distinct_count, self.count()] + [item[1] for item in query_result] index = [\"unique\", \"count\"] +","result if elem[1] != None ] ), ) cmax = \"DECODE({}, {}, NULL)\".format(","), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__(","= f\"{close_l}{first_elem};{second_elem}{close_r}\" conditions += [ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN","-------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \"\"\" check_types([(\"n\",","= \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {})","LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} smallest","to solve this issue.\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item","of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]), ] ) if","Parameters ---------- method: str, optional The method to use to aggregate the data.","# entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize #","= { \"index\": [item[0] for item in result], \"count\": [int(item[1]) for item in","func=\"(CASE WHEN {} < {} THEN {} WHEN {} > {} THEN {}","expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers( self,","if not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else:","| \\/ / / / # |______ / / / # |____/ /","using a user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The","a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self,","= sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass","be computed if the parameter is empty or invalid. max_cardinality: int, optional Maximum","boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self):","(\"None\", None)) else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) )",") if distinct_count > max_cardinality: query += ( \"UNION ALL (SELECT 'Others', SUM(count)","input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent","then this method will return the mode of the vColumn. Returns ------- str/float/int","'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING","--------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x: float Input","vColumn. Parameters ---------- by: str, optional vColumn to use to partition the data.","kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds )","Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label","ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ),","THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" )","to display. offset: int, optional Number of elements to skip. Returns ------- tablesample",") executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ),","vDataFrame[].slice : Slices the vColumn using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}',","Robust Z-Score (median and mad). (x - median) / (1.4826 * mad) minmax","method == \"robust_zscore\": if n > 0: warning_message = \"The method 'robust_zscore' is","title = \"Computing WOE & IV of {} (response = {}).\".format(self.alias, y) result","\"heavier\" if it is used to compute other vColumns. Parameters ---------- add_history: bool,","---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count","\"x\"), self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self, func: str, x: float","with the specified name. \\u26A0 Warning : SQL code generation will be slower","vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \"\"\" ---------------------------------------------------------------------------","Verifies if the regular expression is in each of the vColumn records. vDataFrame[].str_count","float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\",","max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str):",") query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {})","Returns ------- bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool","{}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ) else: final_transformation =","required by applicable law or agreed to in writing, software # distributed under","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types( [","empty, names will be generated. include_lowest: bool, optional If set to True, the","element (Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean","\"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method: str,","def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current","must be empty.\" ) conditions, column = [], self.alias for idx in range(len(breaks)","elem in sauv: if \"top\" in elem: if \"percent\" in elem: self.catalog[elem] =","return result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'.","partition the data. method: str, optional The method to use to aggregate the","self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x: float): \"\"\" ---------------------------------------------------------------------------","vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during","IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET {1})","\"WHEN {} < {} THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int)))","\"rose\"]), ] ) donut = True if pie_type == \"donut\" else False rose","\\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/ \\/_/ #","optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills","not (is_numeric) or (method == \"categorical\") ): query = \"\"\"(SELECT {0} || '',","+ result[\"avg\"][0], ) else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {})","True): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as",") result = executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx,","into one unique category. h: float, optional The interval size to convert to","[2 * IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n))","expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return","__repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self,","= [distinct_count, self.count()] + [item[1] for item in query_result] index = [\"unique\", \"count\"]","self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding","[bool]), ] ) method = method.lower() if self.isnum() and method == \"smart\": schema","approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters","# Licensed under the Apache License, Version 2.0 (the \"License\"); # You may","to pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html","nbins: int = -1, k: int = 6, new_category: str = \"Others\", RFmodel_params:","self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features =","+ total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] )","by = self.parent.format_colnames(by) if method == \"auto\": method = \"mean\" if (self.isnum() and","than 1.\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)):","= kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema","optimized number of nbins will be computed. h: float, optional Interval width of","[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","{}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self,","float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input","\".join(query) ) title = \"Describes the statics of {} partitioned by {}.\".format( numcol,","specific TS field from the vColumn (only if the vColumn type is date","{} LIMIT 1\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev =","to 2.\" ) assert len(breaks) == len(labels) + 1 or not (labels), ParameterError(","VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH vdf_table","------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title = \"Describes the","of the vColumn {} named {} was added to the vDataFrame.\".format( self.alias, name","Drops the first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool,","Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label","float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response:","---# def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records","self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date,","str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ----------","After normalizing the data (Z-Score), if the absolute value of the record is","not (schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)):","most frequent categories and merge the other into one unique category. h: float,","== 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)],","Number of digits to keep after the comma. Returns ------- vDataFrame self.parent See",": trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse","the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---# def __len__(self):","> 1) Returns ------- tablesample An object containing the result. For more information,","else: trans = (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method ==","the regular expression in each record of the vColumn. The vColumn will be","of the mean skewness : skewness sum : sum std : standard deviation","be a vDataFrame column if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date","'{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query + rp]","to the offset. For example, if n = 1 then this method will","Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper bound. Returns","PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP","aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes","use \"POWER({}, 2) + 2\". copy_name: str, optional If not empty, a copy","percent of non-missing elements q% : q quantile (ex: 50% for the median)","# ---# def __init__( self, alias: str, transformations: list = [], parent=None, catalog:","different aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0] = ( \"NULL\"","---------- method: str, optional The method to use to aggregate the data. count","(sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem] =","aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str : List of","pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must be greater or equal to","self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent,","percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0],","vDataFrame[].extract : Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice","Encode]: The vColumn {} was transformed using a mean encoding with {} as","func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max( len(self.parent[column].transformations),","-------- vDataFrame[].head : Returns the head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1)","True if the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn","the vColumn based on an aggregation. Parameters ---------- method: str, optional The method","BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads","= '03-11-1993' will filter the data when 'ts' is greater than November 1993","(\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements","a copy with the specified name. \\u26A0 Warning : SQL code generation will","def __init__( self, alias: str, transformations: list = [], parent=None, catalog: dict =","the 'topk' method. new_category: str, optional The name of the merging category when","= {}, response: str = \"\", return_enum_trans: bool = False, ): \"\"\" ---------------------------------------------------------------------------","-------- vDataFrame[].hist : Draws the histogram of the vColumn based on an aggregation.","categories to consider when drawing the box plot. The other categories will be","IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing","vColumn. method: dict, optional Method to use to impute the missing values. auto","self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h), 1) return","list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn","(k < 1) else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS NOT","\"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ]","picked or computed) nbins: int, optional Number of bins. If empty, an optimized","--------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule. Parameters ----------","= 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN","nbins using Random Forest.\", method=\"fetchall\", ) result = [elem[0] for elem in result]","See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn.","close_l = \"<\", \"]\" if labels: label = labels[idx] else: label = f\"{close_l}{first_elem};{second_elem}{close_r}\"","self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name,","func not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr","{0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC","aggregations to compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max","k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if (use_numbers_as_suffix) else","\"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr,","input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0]","transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\":","input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use to","for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", )","THEN {} ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method","expression matches in each of the vColumn records by an input value. vDataFrame[].str_slice","argv[2 * i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent","sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd else: best_h = max(sturges,","winsorize : Clips the vColumn using as lower bound quantile(alpha) and as upper","A RF Regressor will be trained if the response is numerical (except ints","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float","self, breaks: list, labels: list = [], include_lowest: bool = True, right: bool","# |____/ / / # _____________ / / # \\ / / /","100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total)","), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format(","optional Interval width of the bar. If empty, an optimized h will be","(\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int,","\"varchar\", \"text\", ) else: trans = (\"FLOOR({}) || ''\", \"varchar\", \"text\") else: trans","h will be computed if the parameter is empty or invalid. max_cardinality: int,","style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1,","the values lesser than the lower bound to the lower bound itself and","= False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm.","unit, [str]), (\"start\", start, [bool]), ] ) start_or_end = \"START\" if (start) else","= self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return","elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i])","vDataFrame \"heavier\" if it is used to compute other vColumns. Parameters ---------- add_history:","the other types to varchar. same_freq : Computes bins with the same number","Method to use to impute the missing values. auto : Mean for the","(\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of)",") elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the","{}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM","enough values to compute the Equal Frequency discretization\" ) total, query, nth_elems =",": Replaces the upper and lower outliers by their respective average. null :","index, ) return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return","float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top # ---# def mul(self,","if some specific records are in the vDataFrame. \"\"\" if isinstance(val, str) or","vColumns will memorize the already computed aggregations to gain in performance. The catalog","Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if the absolute","the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the other","response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be numerical to","= \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if","ELSE NULL END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method == \"mean\":","are using. Returns ------- tablesample An object containing the result. For more information,","\" for i in range(1, n): trans += \"WHEN {} BETWEEN {} AND",": exponential function floor : value down to the next whole number ln","enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias,","import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by:","\", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\",","title = \"Describes the statics of {} partitioned by {}.\".format( numcol, self.alias )","outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha = \"NULL\"","vColumn using the average of the response partitioned by the different vColumn categories.","THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\"))","* FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT","aggregations during the computation. cat_stats : Computes statistics of a numerical column for","ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot",") method = method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError( \"The parameter","## # # __ __ ______ ______ __ __ __ __ __ __","/ / / # |______ / / / # |____/ / / #","= self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp !=","plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5, approx=approx) #","n = 1, len(by) if self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias)","[bool]), ] ) start_or_end = \"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({},","nbins used for the discretization (must be > 1) Returns ------- tablesample An","query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] )","input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])]) assert (lower","'' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\", \"''\")) for elem in","mean_encode(self, response: str): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the","numerical to use a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations","be computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum","labels: list = [], include_lowest: bool = True, right: bool = True, ):","considered as an outlier. use_threshold: bool, optional Uses the threshold instead of the","End Date. For example, time = '03-11-1993' will filter the data when 'ts'","of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"pie_type\", pie_type, [\"auto\",","\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\"Computing the optimized histogram","and (val == None): val = self.mode(dropna=True) if val == None: warning_message =","object See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based","\"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\": values = { \"index\":","vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert","str, transformations: list = [], parent=None, catalog: dict = {} ): self.parent, self.alias,","Jarque-Bera index mad : median absolute deviation max : maximum mean : average","You can write the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame","to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND,","i in range(parameters[\"n_estimators\"]) ] query = \"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM","method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by)","= val.replace(\"'\", \"''\") if val != None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif","value function to the input vColumn. Returns ------- vDataFrame self.parent See Also --------","[\"{}, {}\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \"SELECT {} FROM","OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({})","optional parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes","# ---# def min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns","check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def","already computed aggregations to gain in performance. The catalog will be updated when","vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame","the vColumn based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\",","sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total","\"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime,","using the input method. Parameters ---------- method: str, optional The method to use","{}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY","/ NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query, ) query","int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the","by: str = \"\", method: str = \"density\", of: str = \"\", max_cardinality:","{}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {},","(\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"cat_priority\", cat_priority,","self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func 'x ->","[\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h), 1) return best_h","(ex: 50% to get the median). It can also be a cutomized aggregation","in copy_trans] raise QueryError(\"{}\\nAn Error happened during the filling.\".format(e)) if total > 0:","[int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} -","= -1, k: int = 6, new_category: str = \"Others\", RFmodel_params: dict =","Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize :","the vColumn 'of'. sum : Sum of the vColumn 'of'. q% : q","decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame","BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \",","self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \"AVG({}) OVER (PARTITION BY","http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,","TypeError( \"The column 'numcol' must be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool())","in writing, software # distributed under the License is distributed on an \"AS","cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\",","self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to the vColumn {} using the","= \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] =","[(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for","median : median min : minimum mode : most occurent element percent :","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based","elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations)","else: query = \"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg","is set to 'smart'. A RF Regressor will be trained if the response","by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories to normalize.\", method=\"fetchall\",","---------- method: str, optional The method to use to discretize the vColumn. auto","val += list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) #","import Union # VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox","the vColumn based on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower()","= kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns","------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar","str, Function in pure SQL used to transform the vColumn. The function variable","in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION","warning_message = \"Can not normalize {} using a Robust Z-Score - The MAD","+ rp] query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(),","\\ / _ __|_. _ _ |_) # \\/ (/_| | |(_(_|| \\/","to True, draw a Step Plot. ax: Matplotlib axes object, optional The axes","= max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd","of points to use to evaluate the approximate density function. Increasing this parameter","most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","(only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val,","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def","See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \"\"\" pre_comp","elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor =","list = [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations =","range kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute deviation","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]),","Normalizes the input vColumns using the input method. Parameters ---------- method: str, optional","vColumn has already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll be able","\"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame","with the same number of elements. same_width : Computes regular width bins. smart","int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame","available for categorical variables.\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr =","the alias {new_name}.\\nBy changing the parameter 'new_name', you'll be able to solve this","stddev = std # ---# def store_usage(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn expected","OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe,","topk, ) result = executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k","10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if","root ceil : value up to the next whole number cos : trigonometric","the tail of the vColumn. Parameters ---------- limit: int, optional Number of elements","'order_by' must be a list of at least one element to use to","Back Propagation of the next element (Constant Interpolation). ffill : Propagation of the","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna,","Silverman kernel. nbins: int, optional Maximum number of points to use to evaluate","record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]),","): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median,","e: self.transformations = [elem for elem in copy_trans] raise QueryError(\"{}\\nAn Error happened during","bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn","where the vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter:","\"auto\", max_cardinality: int = 6, numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates","max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations +=","\"{}\\nThe vColumn {} can not be converted to {}\".format( e, self.alias, dtype )","method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method is","self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT {} AS apply_test_feature","self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self):","See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \"\"\" if isinstance(by,","COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality +","correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns","Encodes the vColumn using the mean encoding of a response. \"\"\" import verticapy.stats","';' || (FLOOR({} / {}) * {} + {}{}) || ']'\".format( \"{}\", h,","matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax","to the input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame","square root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional","not (\"cmap\" in kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if","/ # \\/ / / # / / # / / # \\",") return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if self.category() == \"float\"","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean","self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in","func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\",","vColumn by keeping only the input number of digits after the comma. Parameters","DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH vdf_table AS (SELECT * FROM","see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in","= executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k if k >","bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns","from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import * ##","bool, optional How the intervals should be closed. If set to True, the","check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk = \"\" if (k <",") result = executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k if","verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import * ## #","self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit =","\"\"\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an aggregation.","vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL(","\"\"\" check_types( [ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]),","will be computed. h: float, optional Interval width of the bar. If empty,","(\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\",","---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False","{}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS","float): category, ctype = \"float\", \"float\" elif method == \"0ifnull\": category, ctype =","k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {} AS {}, {} AS","Parameters ---------- breaks: list List of values used to cut the vColumn. labels:","self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the func","\" UNION ALL \".join(query), nbins - 1 ) result = executeSQL( query=query, title=\"Computing","self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in transformations], )","= self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias)","float, optional Interval width if the vColumn is numerical or of type date","q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str):","b). Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage :","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns","category of the vColumn. The category will be one of the following: date","\"The column 'numcol' must be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else","method to use to discretize the vColumn. auto : Uses method 'same_width' for","------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes","method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \"\"\" ---------------------------------------------------------------------------","\"s were \" if len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__( \"[Get","def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different","if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import","return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n","of the different transformations. \"\"\" # # Special Methods # # ---# def","like: even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 *",") if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return self.parent # ---#","error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes","express or implied. # See the License for the specific language governing permissions","acos : trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric","+= [name] all_new_features += [name] conj = \"s were \" if len(all_new_features) >","= 0 self.catalog[\"std\"] = 1 elif method == \"minmax\": self.catalog[\"min\"] = 0 self.catalog[\"max\"]","can also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes","if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val += list(args)","hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def","median is returned. By setting this parameter to False, the function's performance can","1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l,","elements to be used as categorical. The less frequent elements will be gathered","4) elif h > 0.000001: h = round(h, 6) if self.category() == \"int\":","\"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn","- avg) / std robust_zscore : Normalization using the Robust Z-Score (median and","numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See","{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count()","(\"nbins\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from","draw a Step Plot. ax: Matplotlib axes object, optional The axes to plot","\".join(conditions) + \" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the","of: str = \"\", max_cardinality: int = 6, h: float = 0, pie_type:","most occurent element density unique : cardinality (count distinct) var : variance Other","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func: list","categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn","ParameterError( \"Parameter 'k' must be greater or equals to 2 in case of","+ \", {})\".format(len(distinct_elements)) self.transformations += [(expr, \"int\", \"int\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\"count\"] = self.parent.shape()[0]","- {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\".format(","[ ( \"({} - {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if","[elem[0] for elem in result] elif self.isnum() and method in (\"same_width\", \"auto\"): if","\"int\") # ---# def iv_woe(self, y: str, nbins: int = 10): \"\"\" ---------------------------------------------------------------------------","elements. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {} WHERE","topk(self, k: int = -1, dropna: bool = True): \"\"\" --------------------------------------------------------------------------- Returns the","---# def nsmallest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ----------","str = \"\", method: str = \"density\", of: str = \"\", max_cardinality: Union[int,","float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx else \"\" return self.aggregate(func=[prefix","() FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha","a RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a","\"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ),","See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds","# \\ / / / # \\_______/ / / # ______ / /","(\"same_width\", \"auto\"): if not (h) or h <= 0: if nbins <= 0:","Applies the absolute value function to the input vColumn. Returns ------- vDataFrame self.parent","def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from the","with 0 and 1 (1 meaning global outlier). \"\"\" check_types( [ (\"alpha\", alpha,","vColumn is numerical or of type date like. Optimized h will be computed","Random Forest with 20 trees and a maximum depth of 10. response: str,","vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval width of","= \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for","for Normalization\") return self.parent # ---# def nsmallest(self, n: int = 10): \"\"\"",") for elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def","for elem in order_by] + by) by = self.parent.format_colnames(by) if method == \"auto\":","{}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for k in range(max_floor): self.transformations","a response column to find the most relevant interval to use for the","copy will be created using the input Name. Returns ------- vDataFrame self.parent See",": standard error of the mean skewness : skewness sum : sum std","(prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first","vColumn records. vDataFrame[].extract : Extracts the regular expression in each record of the","be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers","\"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol'","= [distinct_count] + result index = [ \"unique\", \"count\", \"mean\", \"std\", \"min\", \"approx_25%\",","using an input 'quantile'. Parameters ---------- x: float A float between 0 and","# ---# def str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn.","[float, int]), (\"upper\", upper, [float, int])]) assert (lower != None) or (upper !=","# ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns -------","the input vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn","= executeSQL( query=query, title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\", )","If empty, an optimized h will be computed. ax: Matplotlib axes object, optional","\"robust_zscore\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor","): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ----------","mad : median absolute deviation max : maximum mean : average median :","min(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum","[\"name\", \"dtype\"] + index, \"value\": [self.alias, self.ctype()] + result, } if ((is_date) and","datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool =","mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self): \"\"\" ---------------------------------------------------------------------------","Extracts a specific TS field from the vColumn (only if the vColumn type","to 'smart'. A RF Regressor will be trained if the response is numerical","the Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if the","vColumn category. In this case, the parameter 'numcol' must be defined. numerical :","vColumn to use to order the data. The vColumn type must be date","The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to replace.","ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER","method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"]","try: if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ):","[], self.distinct() if len(cat) == 1: lp, rp = \"(\", \")\" else: lp,",") except: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {}","vColumn from the vDataFrame. Dropping a vColumn means simply not selecting it in","vColumn. You can write the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The","- sauv[\"mean\"]) / sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem]","\"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\",","\"\" query = \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*)","FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,","functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws","self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str = \"density\",","title=title) result.values[\"index\"] += [\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"]","n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns -------","and offers beautiful graphical options. # # VerticaPy aims to do all of","(\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins,","Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog of pre-computed","self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches for the","by: list, optional vColumns used in the partition. order_by: list, optional List of","of the vColumn records. vDataFrame[].extract : Extracts the regular expression in each record","30): \"\"\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur,","using the mean encoding of a response. \"\"\" if self.category() in [\"date\", \"float\"]:","vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the input vColumns.","ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any optional","optional How the intervals should be closed. If set to True, the intervals","expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr)","result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"]","regular expression is in each of the vColumn records. vDataFrame[].str_count : Computes the","asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube","method = \"mean\" if (self.isnum() and self.nunique(True) > 6) else \"mode\" total =","vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) #","( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER (PARTITION","input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---# def fill_outliers(","if not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start +=","when method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead","in (\"same_width\", \"auto\"): if not (h) or h <= 0: if nbins <=","\\/ # _ # \\ / _ __|_. _ _ |_) # \\/","TypeError(\"The vColumn must be numerical for Normalization\") return self.parent # ---# def nsmallest(self,","func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -=",": cardinality (count distinct) var : variance Other aggregations could work if it","be trained if the response is numerical (except ints and bools), a RF","* ({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int = 10): \"\"\" ---------------------------------------------------------------------------","add_history: bool, optional If set to True, the information will be stored in","= \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations +","DESC\" partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column in by])","List of values used to cut the vColumn. labels: list, optional Labels used","pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY","from the vDataFrame.\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float","{} ORDER BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias,","arguments (example, power or mod), 'x' represents the second argument. Returns ------- vDataFrame","in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 *","= ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The","BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing","the precision but will also increase the time of the learning and scoring","vDataFrame.plot : Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\",",") title = \"Describes the statics of {} partitioned by {}.\".format( numcol, self.alias","prefix_sep.replace('\"', \"_\") if not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n","ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT","method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if method","the input method. Parameters ---------- method: str, optional The method to use to","must be defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality:","1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({})","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe :","the vDataFrame by using an advanced analytical function on a specific vColumn. \"\"\"","by: str = \"\", bandwidth: float = 1.0, kernel: str = \"gaussian\", nbins:","than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent","gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] = True if","Dummies]: One hot encoder was applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias,","is only available on type numeric|date\" ) if self.isnum(): result = ( self.parent.describe(","= \" WHERE {} IS NOT NULL\".format(self.alias) if (dropna) else \"\" query =","= 6, new_category: str = \"Others\", RFmodel_params: dict = {}, response: str =","the histogram of the vColumn based on an aggregation. \"\"\" check_types( [ (\"method\",","Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float mad See","len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks' must be greater or equal","the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif",": 0 when the vColumn is null, 1 otherwise. expr: str, optional SQL","approximate median is returned. By setting this parameter to False, the function's performance","else: for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func,","if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop <","------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box","\\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/ \\/_/ \\/_/","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"min\"]).values[self.alias][0] #","True, the approximate median is returned. By setting this parameter to False, the","( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else:","self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] =","< 50): try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP","in each of the vColumn records. The vColumn will be transformed. Parameters ----------",": trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp :","in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in",": median. mode : mode (most occurent element). 0ifnull : 0 when the","self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", ) top","/ undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns","range : difference between the max and the min sem : standard error","the vDataFrame.\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self, func:","use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter. alpha: float,","IS NULL\".format(self.alias) if (category in (\"None\", None)) else \" WHERE {} = '{}'\".format(","if elem[0] != None else \"NULL\", elem[2] if elem[2] != None else \"NULL\",","elem[2] != None else \"NULL\", ) for elem in result if elem[2] !=","index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count()","the dummies. drop_first: bool, optional Drops the first dummy to avoid the creation","def pie( self, method: str = \"density\", of: str = \"\", max_cardinality: int","data when 'ts' is lesser than November 1993 the 3rd. end_date: str /","x != 0, ValueError(\"Division by 0 is forbidden !\") return self.apply(func=\"{} / ({})\".format(\"{}\",","method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---# def","({}) THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join( [ \"'{}'\".format(str(elem).replace(\"'\",","except in compliance with the License. # You may obtain a copy of","to use to compute the aggregation. max_cardinality: int, optional Maximum number of the","> 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return","- The MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif",": trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root tan","{})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun","__ __ __ __ __ __ __ # /\\ \\ / / /\\","sauv[\"max\"] - sauv[\"min\"] ) except: pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0",") if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold *","cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to use","BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 ) result = executeSQL(","number of elements. same_width : Computes regular width bins. smart : Uses the","\"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [","deviation max : maximum mean : average median : median min : minimum","{}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the descriptive statistics","int, optional The integer k of the 'topk' method. new_category: str, optional The","if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return self.parent # ---# def","'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING","query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 -","{})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\" ---------------------------------------------------------------------------","pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0 THEN 0","if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in","{}\".format( e, self.alias, dtype ) ) # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates","-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]),","('prefix', 'prefix_sep'), you'll be able to solve this \" \"issue.\" ) for k","the histogram of the vColumn based on an aggregation. Parameters ---------- method: str,","decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ----------","+= [str(total)] total += nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"]","xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param,","func: list List of the different aggregation. aad : average absolute deviation approx_unique","number of nbins will be computed. h: float, optional Interval width of the","= offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def","Slices the vColumn. The vColumn will be transformed. Parameters ---------- start: int Start","elif self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {}","parameter 'labels' + 1 or parameter 'labels' must be empty.\" ) conditions, column","/ EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS /","axes object See Also -------- vDataFrame.bar : Draws the Bar Chart of the","vDataFrame can have multiple children vColumns whereas one vColumn can only have one","return top # ---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn","= self.mode(dropna=True) if val == None: warning_message = \"The vColumn {} has no","in performance. The catalog will be updated when the parent vDataFrame is modified.","def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns -------","in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ),","str(distinct_elements[k]).replace('\"', \"_\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the","from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) #","query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format","in executeSQL( query=query, title=\"Computing the average of the {}'s lower and upper outliers.\".format(","0: warning_message = \"Can not normalize {} using the MIN and the MAX.","h = round(h, 4) elif h > 0.000001: h = round(h, 6) if","result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the","will be considered as an outlier. use_threshold: bool, optional Uses the threshold instead","statistics of a numerical column for each vColumn category. In this case, the","Z-Score - The Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return","= sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) for elem","pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot","ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events",") ) # ---# def avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg'","= \"The vColumn {} has no mode (only missing values).\\nNothing was filled.\".format( self.alias","bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters","USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\".format( self.alias,","assert index.step in (1, None), ValueError( \"vColumn doesn't allow slicing having steps different","(nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", ) ] if method !=","vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk =","gen_cmap()[0] else: if not (\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] =","will be slower if the vDataFrame has been transformed multiple times, so it's","self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__(","# ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() >","computed. nbins: int, optional Number of bins used for the discretization (must be","{} < {} THEN {} WHEN {} > {} THEN {} ELSE {}","[ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ]","VerticaPy is a Python library with scikit-like functionality for conducting # data science","result = executeSQL( query=query, title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\",","discretization (must be > 1) Returns ------- tablesample An object containing the result.","------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time","parameter to pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/","(self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query =","using the mean encoding of a response. \"\"\" check_types( [ (\"prefix\", prefix, [str]),","Area Plot. step: bool, optional If set to True, draw a Step Plot.","memory usage. Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage","---# def aggregate(self, func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" ---------------------------------------------------------------------------","return self.parent # ---# def fill_outliers( self, method: str = \"winsorize\", threshold: float","(date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles","(\"threshold\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha,","category is date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn","based on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\",","= self.parent.format_colnames(column) columns += [column] if not (\"cmap\" in kwargs): from verticapy.plot import","model.drop() return result except: model.drop() raise # ---# def describe( self, method: str",") return self.parent # ---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","most occurent elements and their distributions as percents. Parameters ---------- k: int, optional","True, use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the","optional The type of pie chart. auto : Regular pie chart. donut :","represents Q1. approx: bool, optional If set to True, the approximate quantile is","( \"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM","must be equal to the length of parameter 'labels' + 1 or parameter","COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS","to use to normalize. zscore : Normalization using the Z-Score (avg and std).",": Returns the vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if","index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \"vColumn doesn't allow","= method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if","'numcol' must be numerical\" ) cast = \"::int\" if (self.parent[numcol].isbool()) else \"\" query,","with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) return","optional vColumn to use to partition the data. h: float, optional Interval width","vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val","by an offset and a limit). Parameters ---------- limit: int, optional Number of","deviation approx_unique : approximative cardinality count : number of non-missing elements cvar :","def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn.","verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #","str, optional The describe method. auto : Sets the method to 'numerical' if","percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3,","---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function to the input","self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", ) top = None if not","= index.start if not (isinstance(index_start, int)): index_start = 0 if index_start < 0:","the vColumn. \"\"\" check_types( [ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\",","is equal to 0, an optimised interval will be computed. nbins: int, optional","--------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also","the search. See Also -------- vDataFrame.isin : Looks if some specific records are","== \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\", \"avg\",","ord\".format( self.alias, query, ) title = \"Computing WOE & IV of {} (response","1993 the 3rd. end_date: str / date, optional Input End Date. For example,","'of' (ex: 50% to get the median). It can also be a cutomized","of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins,","a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h,","kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema):","with the method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The vColumn must","\"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent,","[str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ),","partition the data. h: float, optional Interval width if the vColumn is numerical","to partition the data. method: str, optional The method to use to aggregate","see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of the","number of digits after the comma. Parameters ---------- n: int Number of digits","None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({}, {}, NULL)\".format( by[0],","from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\"","/ DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK /","self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object.",": Encodes the vColumn using the mean encoding of a response. \"\"\" import","def describe( self, method: str = \"auto\", max_cardinality: int = 6, numcol: str","\"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by,","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters","WHERE {} IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias )","not normalize {} using the MIN and the MAX. MAX = MIN !\".format(","See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \"\"\" check_types([(\"n\",","[self.alias] check = True if len(args) > 0: column = args[0] elif \"column\"","--------------------------------------------------------------------------- Looks if some specific records are in the vColumn and it returns","(ORDER BY {}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha, self.alias,","method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format(","simply not selecting it in the final generated SQL code. Note: Dropping a","query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha,","partition the TS. start_date: str / date, optional Input Start Date. For example,","on. **style_kwds Any optional parameter to pass to the Matplotlib functions. Returns -------","idea is simple: instead of moving # data around for processing, VerticaPy brings","\" \"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \" \"issue.\"","events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query, )","DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS","= argv[2 * i] THEN argv[2 * i + 1] ... ELSE argv[n]","query_result for item in sublist] # ---# def div(self, x: float): \"\"\" ---------------------------------------------------------------------------","use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError(","See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on",": CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i","and the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self","Evidence (WOE) Table. It tells the predictive power of an independent variable in","Number of elements to display. offset: int, optional Number of elements to skip.","start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \"\"\"","new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError(","'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes","ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events)","width of the vColumns 1 and 2 bars. It is only valid if","method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot(","import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax,","in each of the vColumn records by an input value. \"\"\" check_types([(\"start\", start,","pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the","sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total","2 in case of discretization using the method 'same_freq'\" ) count = self.count()","value down to the next whole number ln : natural logarithm log :","vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame","of the input vColumn based on an aggregation. Parameters ---------- by: str, optional","start, step)) # ---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input","/ date-like vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks'","\", \"_\") .replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}',","\", \".join(by) ), ) if return_trans: return \"({} - {}) / {}({})\".format( self.alias,","set to True, draw a Step Plot. ax: Matplotlib axes object, optional The","------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have","\"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {}, \"regr_slope\":","IS NOT NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),","zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826","length: int, unit: str = \"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices","to partition the TS. start_date: str / date, optional Input Start Date. For","not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\"val\", val, [list])]) val","permissions and # limitations under the License. # # |_ |~) _ _|","the input functions. Parameters ---------- func: list List of the different aggregation. aad","increase the time of the learning and scoring phases. xlim: tuple, optional Set","\"\"\" return self.category() in (\"float\", \"int\") # ---# def iv_woe(self, y: str, nbins:","__ __ # /\\ \\ / / /\\ ___\\ /\\ __ \\ /\\","category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \" WHERE {} IS","> 0: try: if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"]","\\ / / / # \\/ / / # / / # /","op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx == 0 and","will be transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str,","float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]), ] ) if of:","operation pow : number raised to the power of another number round :","the vColumn using the mean encoding of a response. \"\"\" check_types( [ (\"prefix\",","True, the intervals will be closed on the right. Returns ------- vDataFrame self.parent","result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a","+= [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in","method: str = \"auto\"): \"\"\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int,","unit. For example, it can be 'minute' 'hour'... start: bool, optional If set","parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1],","idx == 0 and include_lowest: op1, close_l = \"<=\", \"[\" elif idx ==","{}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title = \"Describes the statics","greater or equals to 2 in case of discretization using the method 'topk'\"","with {} as Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean","# / / # / / # \\ / # \\ / #","be a list of at least one element to use to order the","= None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters","= round(h, 2) elif h > 0.0001: h = round(h, 4) elif h","or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor","kwargs[\"column\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns +=","kernel. nbins: int, optional Maximum number of points to use to evaluate the","= \"\", \"\" for category in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index',","software # distributed under the License is distributed on an \"AS IS\" BASIS,","sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias)","= self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column 'numcol' must be","non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events)","{}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif","interval will be computed. nbins: int, optional Number of bins used for the","in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format(","the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif","[top]} ) return top # ---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies","---------- by: str, optional vColumn to use to partition the data. bandwidth: float,","self.parent[response].isnum(), TypeError( \"The response column must be numerical to use a mean encoding\"","and other statistical information. Parameters ---------- k: int, optional Number of most occurent","used as categorical (No h will be picked or computed) nbins: int, optional","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe","vColumn using multiple statistical aggregations: min, max, median, unique... depending on the input","), print_time_sql=False, ) except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\",","] elif method == \"robust_zscore\": if n > 0: warning_message = \"The method","drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result +","= [self.min()] + result + [self.max()] elif method == \"topk\": assert k >=","approx else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---#","kurt = kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using","{0} ORDER BY COUNT(*) DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count >","be sliced using the floor of the slicing instead of the ceiling. Returns",": Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.","isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity(","= False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot of the","> {} THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha,","[ ( \"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ]","Extracts a specific TS field from the vColumn. \"\"\" check_types( [ (\"length\", length,","q% : q Quantile of the vColumn 'of' (ex: 50% to get the","Chart of the input vColumns based on an aggregation. \"\"\" check_types( [ (\"by\",","for elem in result if elem[1] != None ] ), ) stddev =","+ 1] if right: op1, op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\"","input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return self.apply(func=\"{} * ({})\".format(\"{}\", x)) #","name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name' must not be empty\" ) assert not","Forest on a response column to find the most relevant interval to use","if not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax =","method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN ({}","the donut chart of the vColumn based on an aggregation. \"\"\" if isinstance(pie_type,","category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \"\"\" return","\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a list of","Mean for the numerical and Mode for the categorical vColumns. bfill : Back","self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param,","[tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date,","Plot. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any","to the following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn.","self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\") ]","{})\".format( self.alias, \", \".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in each","Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} )","creating a copy with the specified name. \\u26A0 Warning : SQL code generation",": q Quantile of the vColumn 'of' (ex: 50% to get the median).","See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum","pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp","end_date: str / date, optional Input End Date. For example, time = '03-11-1993'","else: avg, stddev = ( \"AVG({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by)","model_name = '{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i ) for","1e-99) if method.lower() == \"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"):","\".join(by) ), ) else: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format(","self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem","Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response,","of the bar. If empty, an optimized h will be computed. ax: Matplotlib","k of the 'topk' method. new_category: str, optional The name of the merging","= MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1:","\"density\", of: str = \"\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int,","changing the parameter 'new_name', you'll be able to solve this issue.\" ) self.add_copy(new_name)","bool, optional If set to True, the lowest element of the list will","check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division by 0 is forbidden","aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of, [str]),","from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality,","x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns",") for elem in sauv: if \"top\" in elem: if \"percent\" in elem:","the a part of the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist(","# ---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in","be able to solve this \" \"issue.\" ) for k in range(len(distinct_elements) -","Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n **","import Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax =","is date. \"\"\" return self.category() in (\"float\", \"int\") # ---# def iv_woe(self, y:","model.drop() raise # ---# def describe( self, method: str = \"auto\", max_cardinality: int","of the search. Parameters ---------- val: list List of the different records. For","pt_events, CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE","\"mod\", \"pow\", \"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x,","Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also --------","pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the","result = result.values[self.alias] elif (method == \"cat_stats\") and (numcol != \"\"): numcol =","use to aggregate the data. count : Number of elements. density : Percentage","data transformation operations, and offers beautiful graphical options. # # VerticaPy aims to","\"\"\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will be one","all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\"\\\\b{}\\\\b\".format(column.replace('\"', \"\"))), func )","**style_kwds, ) # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std'","is a Python library with scikit-like functionality for conducting # data science projects","\"{}\"), \"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans: return \"({} -","cbrt : cube root ceil : value up to the next whole number","vDataFrame.plot : Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\",","= [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as","power of an independent variable in relation to the dependent variable. Parameters ----------","of the dummies ({name}).\\n\" \"It can be the result of using previously the","\\ \\ \\ \\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\","\"\" query = \"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),","absolute value of the record is greater than the threshold, it will be","THEN {} \".format(\"{}\", upper, upper) if (isinstance(upper, (float, int))) else \"\" ) func","if method.lower() == \"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h","events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))","-------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using an","vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int,","of the current axes. ax: Matplotlib axes object, optional The axes to plot","len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(),","the different categories to [0, n - 1] (n being the vColumn cardinality).","str(distinct_elements[k]).replace(\"'\", \"''\") ) transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn(","index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events =","sauv[\"mean\"]) / sauv[ \"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] -","the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies.","Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\",","(is_numeric) or (method == \"categorical\") ): query = \"\"\"(SELECT {0} || '', COUNT(*)","return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result =","{}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) # ---# def spider(","str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the","warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if","THEN {} \".format(\"{}\", lower, lower) if (isinstance(lower, (float, int))) else \"\" ) upper_when","str, optional Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional","warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\"DECODE({}\"] text_info = \"\\n\" for","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on","optional The describe method. auto : Sets the method to 'numerical' if the","*argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv:","] ) if func not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(),","\"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\",",": Returns True if the vColumn category is date. vDataFrame[].isnum : Returns True","method: str = \"auto\", max_cardinality: int = 6, numcol: str = \"\" ):","vColumn. abs : absolute value acos : trigonometric inverse cosine asin : trigonometric","normalize. zscore : Normalization using the Z-Score (avg and std). (x - avg)","(x - min) / (max - min) by: list, optional vColumns used in","0: op1, close_l = \"<\", \"]\" if labels: label = labels[idx] else: label","vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---# def quantile(self,","RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]), (\"h\", h, [int, float]), (\"response\", response, [str]), (\"nbins\",","name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s were","deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame","if elem[1] != None else \"NULL\", ) for elem in result if elem[1]","h: float, optional Interval width of the bar. If empty, an optimized h","of vColumn distinct elements to be used as categorical. The less frequent elements","/ TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See","during the computation. n: int, optional Integer corresponding to the offset. For example,","if not (dropna) and (pre_comp != None): return pre_comp assert n >= 1,","undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the","------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field","upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha =","if right: op1, op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else: op1,","'topk' method. new_category: str, optional The name of the merging category when using","- sauv[\"approx_50%\"]) / ( 1.4826 * sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem]","Parameters ---------- alias: str vColumn alias. transformations: list, optional List of the different","function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x:","Returns the head of the vColumn. vDataFrame[].tail : Returns the tail of the","( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\"","* FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except:","the vColumn using 'std' (Standard Deviation). Returns ------- float std See Also --------","def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn.","the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters","None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) / ( 1.4826","tells the predictive power of an independent variable in relation to the dependent","[] while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total","response, [str]), (\"nbins\", nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\",","\"auto\"): if not (h) or h <= 0: if nbins <= 0: h","executeSQL( query=query, title=\"Computing the average of the {}'s lower and upper outliers.\".format( self.alias","not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality,","using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent # ---#","False, the function's performance can drastically decrease. Returns ------- float/str median See Also","use to partition the data. h: float, optional Interval width if the vColumn","if \"count\" in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100","(self.category() == \"float\"): trans = ( \"'[' || FLOOR({} / {}) * {}","= True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ----------","outliers by their respective average. null : Replaces the outliers by the NULL","_repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val #","= \"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT","operations, and offers beautiful graphical options. # # VerticaPy aims to do all","parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object","TS (Time Series) vColumn to use to order the data. The vColumn type","elements and their distributions as percents. Parameters ---------- k: int, optional Number of","= \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def","memorize the already computed aggregations to gain in performance. The catalog will be","query = \"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL","the statics of {} partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query,","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot","str, optional vColumn to use to partition the data. h: float, optional Interval","executeSQL( query, title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min,","to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \"\"\" if isinstance(func,","apply the function: x -> x^2 + 2 use \"POWER({}, 2) + 2\".","f\"A vColumn has already the alias {new_name}.\\nBy changing the parameter 'new_name', you'll be",") setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] self.parent.__add_to_history__( \"[Add Copy]:","For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame","------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of the vColumn","of the vColumn 'of'. min : Minimum of the vColumn 'of'. max :","enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) )","WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias,","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"variance\"]).values[self.alias][0]","TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also","(PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) else: new_column = \"COALESCE({},","vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\"))","trans = \"(CASE \" for i in range(1, n): trans += \"WHEN {}","the vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn is","bool, optional If set to True, NULL values will not be considered during",") except: pass total = int(total) conj = \"s were \" if total","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by:","h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\") else \"\"","AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max","return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \"\"\"","not apply it. This parameter is very useful for testing to be able","func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor =","number of points to use to evaluate the approximate density function. Increasing this","\"CASE WHEN \" + \" WHEN \".join(conditions) + \" END\" self.apply(func=expr) # ---#","---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str,","See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies","({}) x ORDER BY ord\".format( self.alias, query, ) title = \"Computing WOE &","implied. # See the License for the specific language governing permissions and #","used are the median and two input quantiles. Parameters ---------- ts: str TS","aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \"\"\" ---------------------------------------------------------------------------","aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and 2 bars.","will be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent","the method is in ffill|pad|bfill|backfill then 'order_by' must be a list of at","BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, )","method: str = \"density\", of: str = \"\", max_cardinality: int = 6, h:","categories of {}.\".format( k if k > 0 else \"\", self.alias ), method=\"fetchall\",","vDataFrame[].isdate : Returns True if the vColumn category is date. \"\"\" return self.category()","vDataFrame column if the method is 'cat_stats'\" ) distinct_count, is_numeric, is_date = (","the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies","xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn Density","one of the dummies ({name}).\\n\" \"It can be the result of using previously","descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1] for","{}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts","of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent","raise ConversionError( \"{}\\nThe vColumn {} can not be converted to {}\".format( e, self.alias,","2 in case of discretization using the method 'topk'\" ) distinct = self.topk(k).values[\"index\"]","- {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev ),","self.parent # ---# def fill_outliers( self, method: str = \"winsorize\", threshold: float =","return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","of the vColumn 'of'. sum : Sum of the vColumn 'of'. q% :","function floor : value down to the next whole number ln : natural","by == []: if fun == \"AVG\": val = self.avg() elif fun ==","empty, an optimized h will be computed. ax: Matplotlib axes object, optional The","to aggregate the data. count : Number of elements. density : Percentage of","using an advanced analytical function on a specific vColumn. \"\"\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose()","\"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*)","encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans, [bool]),","= self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func) or","# ---# def isnum(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical,","2 use \"POWER({}, 2) + 2\". copy_name: str, optional If not empty, a","bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of","of nbins. If empty, an optimized number of nbins will be computed. h:","except: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE {} IS","list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with","\"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object","kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","), title=\"Computing the different categories to normalize.\", method=\"fetchall\", ) for i in range(len(result)):","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---#","None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1] == None) else","ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent","method. new_category: str, optional The name of the merging category when using the","See Also -------- vDataFrame.case_when : Creates a new feature by evaluating some conditions.","# See the License for the specific language governing permissions and # limitations","GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories","kwargs): from verticapy.plot import gen_cmap kwargs[\"cmap\"] = gen_cmap()[0] else: if not (\"color\" in",": Returns True if the vColumn is numerical. \"\"\" return self.category() == \"date\"","self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if","str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn.","the computation. cat_stats : Computes statistics of a numerical column for each vColumn","AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to plot on.","THEN '[{};{}]' \".format( \"{}\", result[i - 1], result[i], result[i - 1], result[i] )","elem in self.transformations] total = self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor","\"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if approx","/ / / # \\/ / / # / / # / /","of most occurent elements to return. Returns ------- tablesample An object containing the","PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT","\"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {}","using the following mapping:{}\".format( self.alias, text_info ) ) return self.parent # ---# def","start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date,","optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies.","to the vDataFrame by using an advanced analytical function on a specific vColumn.","= verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if","method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()] + result + [self.max()] elif method ==","- limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {} AS {}","IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1]","in elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem == None:","be picked or computed) nbins: int, optional Number of bins. If empty, an","other categories will be filtered. ax: Matplotlib axes object, optional The axes to","h = round(h, 2) elif h > 0.0001: h = round(h, 4) elif","optimal vColumn bar width. Parameters ---------- method: str, optional Method to use to","Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent","bins. If empty, an optimized number of bins will be computed. h: float,","== \"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) ==","the different categories to normalize.\", method=\"fetchall\", ) for i in range(len(result)): if result[i][2]","= (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or","1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also --------","------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","top # ---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by","str = \"_\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \"\"\"",") ) return self.parent # ---# def fillna( self, val=None, method: str =","See Also -------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])])","( sauv[\"max\"] - sauv[\"min\"] ) except: pass if method == \"robust_zscore\": self.catalog[\"median\"] =","Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to pass to","in the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An","{} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\".format(","/ ({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({} - {}) /","self.alias ) warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if n ==","close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx == 0 and include_lowest:","(must be > 1) Returns ------- tablesample An object containing the result. For","sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) +","Also -------- vDataFrame[].apply : Applies a function to the vColumn. \"\"\" check_types( [","aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]),","dtype = ctype # ---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a","{}.\".format(self.alias), method=\"fetchall\", ) return [item for sublist in query_result for item in sublist]","\\/ # / # VerticaPy is a Python library with scikit-like functionality for","to use when the parameter method is set to 'cat_stats'. Returns ------- tablesample","instead of the parent vDataFrame. This parameter is used for testing purpose. Returns","{op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN \" + \" WHEN","!= None), ParameterError( \"At least 'lower' or 'upper' must have a numerical value\"","!= \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The column","/ / / # \\ / / / # \\/ / / #","\"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater or equals","\"At least 'lower' or 'upper' must have a numerical value\" ) lower_when =","result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] += [\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return","_ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______","), \"varchar\", \"text\", ) elif self.isnum() and method == \"same_freq\": assert nbins >=","rp = \"\", \"\" for category in cat: tmp_query = \"\"\"SELECT '{0}' AS","\"regr_slope\": {}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem in catalog:","Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt","return self.parent # ---# def median( self, approx: bool = True, ): \"\"\"","\"\" ) func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent","[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf(","in result], \"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2], 3)) for item","vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes","min : Minimum of the vColumn 'of'. max : Maximum of the vColumn","Q1. approx: bool, optional If set to True, the approximate quantile is returned.","function to the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\",","kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum","median( self, approx: bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","parameter 'numcol' must be a vDataFrame column if the method is 'cat_stats'\" )","\"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can not normalize {} using a","int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0]","WHEN non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events -","# ---# def mode(self, dropna: bool = False, n: int = 1): \"\"\"","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0]","new_column = \"DECODE({}, NULL, 0, 1)\" elif method in (\"mean\", \"avg\", \"median\"): fun","lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than","({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format(","(\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or (","index = result.values[\"index\"] result = result.values[self.alias] elif (method == \"cat_stats\") and (numcol !=","( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name)","vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a","/ (max - min) by: list, optional vColumns used in the partition. return_trans:","else \" WHERE {} = '{}'\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query +=","== \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\",","Start of the slicing. step: int Size of the slicing. Returns ------- vDataFrame","the next whole number ln : natural logarithm log : logarithm log10 :","elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args,",": Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') >","BY {})\".format( self.alias, \", \".join(by) ), ) else: cmax, cmin = ( \"MAX({})","# ---# def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n","threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias])",") + \".\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self,","vColumn labeled with 0 and 1 (1 meaning global outlier). \"\"\" if isinstance(method,","self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \"categorical\"): result =","(self.isnum() and method == \"same_freq\") or ( self.isnum() and method == \"smart\" ):","return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self,","{} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL","= True, alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the","# # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average","self.category() == \"date\" # ---# def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks","vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined","= 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%',","Input End Date. For example, time = '03-11-1993' will filter the data when","# \\/ / / # / / # / / # \\ /","density( self, by: str = \"\", bandwidth: float = 1.0, kernel: str =","int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn.","columns naming.\\nBy changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be able","the vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex: 50%","'hour'... start: bool, optional If set to True, the record will be sliced","from verticapy.toolbox import * from verticapy.errors import * ## # # __ __","to use to partition the data. bandwidth: float, optional The bandwidth of the","std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float","class vColumn(str_sql): \"\"\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If",": Uses the Random Forest on a response column to find the most","return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) ) #","Percentage of the distribution. mean : Average of the vColumn 'of'. min :","to True, draw an Area Plot. step: bool, optional If set to True,","bound to the lower bound itself and the values higher than the upper","if the vColumns are numerical. Optimized h will be computed if the parameter","list = [], order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements","exponential function floor : value down to the next whole number ln :","if \"agg\" not in kwargs: query = \"SELECT {} AS {} FROM {}","the Median will be drawn. ax: Matplotlib axes object, optional The axes to","\"{}\", partition_by, order_by_ts ) if method in (\"mean\", \"median\") or isinstance(val, float): category,","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot :","= self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition =","be drawn. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds","if self.category() == \"int\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category()",": Returns the vDataFrame memory usage. \"\"\" import sys total = ( sys.getsizeof(self)","points to use to evaluate the approximate density function. Increasing this parameter will","self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = (","to sort the data when using TS methods. Returns ------- vDataFrame self.parent See","vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn","\"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int, optional","= 0, pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","_ __|_. _ _ |_) # \\/ (/_| | |(_(_|| \\/ # /","Converts the vColumn to the input type. Parameters ---------- dtype: str New type.","= quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has","rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\" ---------------------------------------------------------------------------","Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with","vColumns 1 and 2 to be used as categorical (No h will be","in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype,","int, unit: str = \"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and","x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ----------","+ sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total +=","mod : remainder of a division operation pow : number raised to the","catalog: dict, optional Catalog where each key corresponds to an aggregation. vColumns will","# ---# def fillna( self, val=None, method: str = \"auto\", expr: str =","vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self):","item in query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose()",") category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols:","vColumns.\" ) assert len(breaks) >= 2, ParameterError( \"Length of parameter 'breaks' must be","{} using a Z-Score - The Standard Deviation is null !\".format( self.alias )","ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not","------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar","if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\", x))","with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode","DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR","\\-./\\ \\ \\ \\ \\-. \\ # \\ \\__| \\ \\_____\\ \\ \\_____\\","/ Weight Of Evidence (WOE) Table. It tells the predictive power of an",": Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled","using 'sem' (standard error of mean). Returns ------- float sem See Also --------","vColumn outliers. mean : Replaces the upper and lower outliers by their respective","Parameters ---------- func: str, Function in pure SQL used to transform the vColumn.","\"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", )","------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the","limit = 0 limit = \" LIMIT {}\".format(limit) else: limit = \"\" query","the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division","= 0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ):","AS events FROM ({}) x GROUP BY 1\".format( self.alias, y, y, query, )","ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return","function. Increasing this parameter will increase the precision but will also increase the","alpha: float = 0.05 ): \"\"\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters","\"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks: list","Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the","picked or computed) ax: Matplotlib axes object, optional The axes to plot on.","None: new_column = \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr)","True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x:","\"[Mean Encode]: The vColumn {} was transformed using a mean encoding with {}","!= None ] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format(","equal to 0, an optimised interval will be computed. nbins: int, optional Number","\"tan\", \"tanh\", ], ), (\"x\", x, [int, float]), ] ) if func not","vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \"\"\"","total > 1 else \" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__(",": Jarque-Bera index mad : median absolute deviation max : maximum mean :","\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC","|_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # / __ `\\ / /","approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str","renamed '{}'.\".format(old_name, new_name) ) return parent # ---# def round(self, n: int): \"\"\"","pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self, to_replace: str, value: str = \"\"):","**style_kwds, ) # ---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn","catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the","ffill : Propagation of the first element (Constant Interpolation). mean : Average. median","1: lp, rp = \"(\", \")\" else: lp, rp = \"\", \"\" for","float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist","invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1 and","vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])])","']'\".format( \"{}\", h, h, \"{}\", h, h, h, floor_end ), \"varchar\", \"text\", )","vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding","= 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END","numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use to","returns the new vDataFrame of the search. Parameters ---------- val: list List of","{}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {}, \"regr_count\": {}, \"regr_intercept\": {}, \"regr_r2\": {},","self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna: bool =","quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers :","1.4826 * sauv[\"mad\"] ) elif method == \"zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"mean\"])","kurtosis # ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection","self.parent.__add_to_history__( \"[Drop]: vColumn {} was deleted from the vDataFrame.\".format(self.alias) ) return parent #","use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot","\"Computing WOE & IV of {} (response = {}).\".format(self.alias, y) result = to_tablesample(query,","= ( \"label_encode is only available for categorical variables.\" ) warnings.warn(warning_message, Warning) else:","\"\"\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn and it","of the vColumn records. vDataFrame[].str_count : Computes the number of matches for the","in enumerate(result): result[idx][0] = ( \"NULL\" if (elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\"))","input element from the vColumn. Parameters ---------- x: float If the vColumn type","vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate :","AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result =","def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values","value{} filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\")","be considered as categorical. numcol: str, optional Numerical vColumn to use when the","field from the vColumn (only if the vColumn type is date like). The","AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT","vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode","AS {}, {} AS ord, {}::int AS {} FROM {}\".format( trans, self.alias, self.alias,","the 2 quantiles used to draw the Plot. start_date: str / date, optional","Drops the vColumn missing values. \"\"\" if isinstance(by, str): by = [by] if","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\"","idx == 0: op1, close_l = \"<\", \"]\" if labels: label = labels[idx]","= 1.0, kernel: str = \"gaussian\", nbins: int = 200, xlim: tuple =","func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) # ---# def","Each transformation must be similar to the following: (function, type, category) parent: vDataFrame,","(method != \"numerical\")) or not (is_numeric) or (method == \"categorical\") ): query =","will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also","max_cardinality, [int, float]), (\"h\", h, [int, float]), (\"nbins\", nbins, [int, float]), ] )","date, False otherwise. Returns ------- bool True if the vColumn category is date.","a new vColumn labeled with 0 and 1 (1 meaning global outlier). \"\"\"","optional Maximum number of vColumn distinct elements to be used as categorical. The","density function. Increasing this parameter will increase the precision but will also increase","See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\",","See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate","self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() <","[str]), ] ) method = method.lower() assert (method != \"cat_stats\") or (numcol), ParameterError(","by grouping by elements, please use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return","int = 0, h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","encoding with {} as Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The","different records. For example, to check if Badr and Fouad are in the","smallest elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns -------","or computed) h: float, optional Interval width of the bar. If empty, an","unit: str = \"second\", start: bool = True): \"\"\" --------------------------------------------------------------------------- Slices and transforms","- {}) / ({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({} -","Table. It tells the predictive power of an independent variable in relation to","** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float","ints and bools), a RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10}","self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s were \" if len(all_new_features)","\"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) )","'{}' was transformed with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"),","= get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if","!= \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh is only available","(\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold: result =","axes object See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn","\"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem","-------- vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])])","[str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") ) )","10} to train a Random Forest with 20 trees and a maximum depth","Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use","decimal places sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic","== \"int\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\")","by) by = self.parent.format_colnames(by) if method == \"auto\": method = \"mean\" if (self.isnum()","--------------------------------------------------------------------------- Verifies if the regular expression is in each of the vColumn records.","expression is in each of the vColumn records. vDataFrame[].extract : Extracts the regular","'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the","--------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float A","xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0],","[cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"h\", h, [int,","\"{}\", \", \".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by,",") executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype,","= by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for","--------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by: str, optional","the n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns -------","{}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in (\"mean\", \"median\") or isinstance(val,","the vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn can","nbins, [int, float]), ( \"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\",","to use to partition the data. method: str, optional The method to use","method == \"topk\": assert k >= 2, ParameterError( \"Parameter 'k' must be greater","not in (\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr =","= \"\", bandwidth: float = 1.0, kernel: str = \"gaussian\", nbins: int =","\"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent # ---#","input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\" ---------------------------------------------------------------------------","sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head","return pre_comp store_usage = executeSQL( \"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ),","bool, optional Returns the transformation instead of the vDataFrame parent and do not","lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame","user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn",": Computes bins with the same number of elements. same_width : Computes regular","for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name,","use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} < {}\".format(","[], order_by: list = [], ): \"\"\" --------------------------------------------------------------------------- Fills missing elements in the","mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\"Computing the average","the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a","= [\"unique\", \"count\"] + [item[0] for item in query_result] else: result = (","the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame The vDataFrame of the search.","result = executeSQL( query, title=\"Computing the top{} categories of {}.\".format( k if k","\"text\", ) elif self.isnum() and method == \"same_freq\": assert nbins >= 2, ParameterError(","not (\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"] = gen_colors()[0] if not","---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor","---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn.","\"\\n\" for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ]","analytics and machine learning features. It supports the # entire data science life","/ / # \\_______/ / / # ______ / / # \\ /","if (dropna) else \" \" result = executeSQL( \"SELECT {} FROM (SELECT {},","title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", ) if method == \"winsorize\": self.clip(lower=p_alpha, upper=p_1_alpha)","the input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method,","LIMIT 1\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query,","rounds a value to a specified number of decimal places sign : arithmetic","the vColumn is numerical, False otherwise. Returns ------- bool True if the vColumn","times, so it's better practice to use this method when first preparing your","- {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\".format(","stored in Vertica, taking advantage Vertica’s # speed and built-in analytics and machine","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\",","verticapy.errors import * ## # # __ __ ______ ______ __ __ __","|_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ # / __ `\\ /","(\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]), ]","fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {}","See Also -------- vDataFrame[].head : Returns the head of the vColumn. \"\"\" return","custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\")","---# def pie( self, method: str = \"density\", of: str = \"\", max_cardinality:","\\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/ \\/_____/ \\/_____/ \\/_/","the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes","using the input list. Parameters ---------- breaks: list List of values used to","set to True, the lowest element of the list will be included. right:","It tells the predictive power of an independent variable in relation to the","result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99,","and Mode for the categorical vColumns. bfill : Back Propagation of the next","and std). (x - avg) / std robust_zscore : Normalization using the Robust","cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ) else: final_transformation = [","the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values lesser","Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random Forest with 20 trees","except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result = [self.min()]","the data using the input expression. \"\"\" self.parent.filter(\"{} IS NOT NULL\".format(self.alias)) return self.parent","the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also --------","top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top # ---#","int, optional Number of most occurent elements to return. Returns ------- tablesample An","ax = self.parent.search( \"{} = '{}'\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax),","= 8, cat_priority: list = [], ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","list, optional vColumns used in the partition. order_by: list, optional List of the","to the data. # # # Modules # # Standard Python Modules import","order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\".format( \"{}\",","index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if index_start <","{}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\": {},","practice to use this method when first preparing your data. Parameters ---------- new_name:","{} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias,","n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str = \"zscore\",","---------- func: str, Function in pure SQL used to transform the vColumn. The","0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events","{} IS NOT NULL ORDER BY {} ASC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias,","vColumn is numerical, False otherwise. Returns ------- bool True if the vColumn is","of parameter breaks must be equal to the length of parameter 'labels' +","Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes","int, optional Number of elements to skip. Returns ------- tablesample An object containing","\\ / # \\ / # \\/ # _ # \\ / _","is empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements","donut = True if pie_type == \"donut\" else False rose = True if","self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density( self, by: str = \"\", bandwidth: float","< max_cardinality + 1) and (method != \"numerical\")) or not (is_numeric) or (method","val # # Methods # # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","int = 5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a part of","when the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias.","prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first else 0","several processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list,","missing value{} filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was","verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim:","3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width.","use to convert the vColumn. If this parameter is equal to 0, an","aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \"\"\" ---------------------------------------------------------------------------","input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \"\"\"","None ] ), ) executeSQL( \"SELECT {}, {} FROM {} LIMIT 1\".format( avg,","of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot(","or 'upper' must have a numerical value\" ) lower_when = ( \"WHEN {}","a Random Forest with 20 trees and a maximum depth of 10. response:","by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias]","xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column","to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as","\"ABS({} - {}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) )","\\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/ \\/_____/","str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame","self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem in self.catalog:","quantiles used to draw the Plot. start_date: str / date, optional Input Start","when 'ts' is greater than November 1993 the 3rd. plot_median: bool, optional If","vDataFrame input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar(","cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\",","the vColumn using the mean encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\",","in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \"\"\" ---------------------------------------------------------------------------","vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn","filter the data when 'ts' is lesser than November 1993 the 3rd. end_date:","[ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog","None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {} THEN {} WHEN","[\"\"] result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates","to use to partition the TS. start_date: str / date, optional Input Start","the vColumn records. vDataFrame[].extract : Extracts the regular expression in each record of",": rounds a value to a specified number of decimal places sign :","+= nb where = \"WHERE _verticapy_row_nb_ IN ({})\".format( \", \".join([\"1\"] + nth_elems +","\"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\",","--------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method: str, optional","self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\",","-1 if (self.category() == \"int\") else \"\" if (h > 1) or (self.category()","+= \" ELSE NULL END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans: return","- {}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0], threshold ) ) else:","OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query, ) query = \"SELECT","value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\", \"''\"), value.replace(\"'\", \"''\") )","kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\"temp_schema\"] if not (schema): schema =","True if the vColumn category is date, False otherwise. Returns ------- bool True","0: if return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad) else: final_transformation","sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\"","the vDataFrame represents the entire relation, a vColumn can be seen as one","result.values[\"iv\"] += [sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","floor : value down to the next whole number ln : natural logarithm","logarithm log10 : base 10 logarithm mod : remainder of a division operation","---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str","vColumn means simply not selecting it in the final generated SQL code. Note:","is greater than November 1993 the 3rd. area: bool, optional If set to","1) and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\": fun = \"APPROXIMATE_MEDIAN\"","= \"\\n\" for k in range(len(distinct_elements)): expr += [ \"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k)","h, [int, float]), (\"nbins\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of","to use to transform the vColumn. abs : absolute value acos : trigonometric","method == \"minmax\": if n == 0: nullifzero = 0 cmin, cmax =","\\ # \\ \\ \\'/ \\ \\ \\____ \\ \\ \\/\\ \\ \\","parameter breaks must be equal to the length of parameter 'labels' + 1","Average. median : median. mode : mode (most occurent element). 0ifnull : 0","bool, optional If set to True, draw a Step Plot. ax: Matplotlib axes","some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with","\"min\", \"approx_25%\", \"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\": values = {","1) and (method != \"numerical\")) or not (is_numeric) or (method == \"categorical\") ):","elements. \"\"\" if \"agg\" not in kwargs: query = \"SELECT {} AS {}","self.parent # ---# def fillna( self, val=None, method: str = \"auto\", expr: str","def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn","'numcol' must be a vDataFrame column if the method is 'cat_stats'\" ) distinct_count,","MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME","created using the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply",": Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"', \"_\"))","caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most","the head of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn.","/ nbins if h > 0.01: h = round(h, 2) elif h >","isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns","= gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] = True if not (\"figsize\"","the bar. If empty, an optimized h will be computed. pie_type: str, optional","> 1) or (self.category() == \"float\"): trans = ( \"'[' || FLOOR({} /","str Response vColumn. nbins: int, optional Maximum number of nbins used for the","vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes","or (self.category() == \"float\"): trans = ( \"'[' || FLOOR({} / {}) *","to display. Returns ------- tablesample An object containing the result. For more information,","self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int = 5): \"\"\"","y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2,","0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast,","self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except: pass","self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations =","BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans: return \"({} - {})","if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {} < {}","ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format(","20, \"max_depth\": 8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response)","a copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name of","average of the {}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ]","math, re, decimal, warnings, datetime from collections.abc import Iterable from typing import Union","parameter 'labels' must be empty.\" ) conditions, column = [], self.alias for idx","ALL \".join(query) ) title = \"Describes the statics of {} partitioned by {}.\".format(","UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias,","str = \"\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple]","nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0],","len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column,","float, optional The bandwidth of the kernel. kernel: str, optional The method used","be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional","var : variance Other aggregations could work if it is part of the","'minute' 'hour'... start: bool, optional If set to True, the record will be",": Uses method 'same_width' for numerical vColumns, cast the other types to varchar.","columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of =","was successfully done.\") return self.parent # ---# def median( self, approx: bool =","used to draw the Plot. start_date: str / date, optional Input Start Date.","different categories to consider when drawing the box plot. The other categories will","= [elem[0] for elem in result] elif self.isnum() and method in (\"same_width\", \"auto\"):","def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for the","method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\"n_estimators\":","/ # | \\/ / / / # |______ / / / #","Computes the vColumn descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])])","the vColumn category is date, False otherwise. Returns ------- bool True if the","result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the","[int, float])]) query = \"SELECT * FROM {} WHERE {} IS NOT NULL","the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct","higher than the upper bound to the upper bound itself. Parameters ---------- lower:","cmax, cmin, ), \"float\", \"float\", ) ] if method != \"robust_zscore\": max_floor =","fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing the different aggregations.\",","Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar :","Applies a function to the input vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) return","__ # /\\ \\ / / /\\ ___\\ /\\ __ \\ /\\ \\","1) Returns ------- tablesample An object containing the result. For more information, see","result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} < {}\".format( self.alias,","pie_type: str, optional The type of pie chart. auto : Regular pie chart.","THEN {} WHEN {} > {} THEN {} ELSE {} END)\".format( \"{}\", p_alpha,","order_by, ParameterError( \"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a","BY 1) x ORDER BY verticapy_agg DESC\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(),","can not be converted to {}\".format( e, self.alias, dtype ) ) # ---#","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from","natural logarithm log : logarithm log10 : base 10 logarithm mod : remainder","vColumns outliers using the input method. Parameters ---------- method: str, optional Method to","if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": if","Keeps the topk most frequent categories and merge the other into one unique","elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"): assert order_by, ParameterError( \"If the method","== \"mode\") and (val == None): val = self.mode(dropna=True) if val == None:","] ) method = method.lower() if self.isnum() and method == \"smart\": schema =","equal to the length of parameter 'labels' + 1 or parameter 'labels' must","the record is greater than the threshold it will be considered as an","applicable law or agreed to in writing, software # distributed under the License","the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object","available only if the parameter 'by' is empty\\nIf you want to normalize by","AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4})","describe method. auto : Sets the method to 'numerical' if the vColumn is","Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the","\"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS","and method == \"smart\" ): n = len(result) trans = \"(CASE \" for","lower and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha == None:","float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = (","[\"top{}\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x: float): \"\"\"","if (method == \"mode\") and (val == None): val = self.mode(dropna=True) if val","[\"store_usage\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \"\"\"","The bandwidth of the kernel. kernel: str, optional The method used for the","\"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or ( self.isnum() and method","AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \"\"\" ---------------------------------------------------------------------------","vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn","the vColumn. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value,","( \"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({} /","BY ord\".format( self.alias, query, ) title = \"Computing WOE & IV of {}","the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the","ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL","able to look at the final transformation. Returns ------- vDataFrame self.parent See Also","NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type","projects on data stored in Vertica, taking advantage Vertica’s # speed and built-in","True if pie_type == \"rose\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)","import math, re, decimal, warnings, datetime from collections.abc import Iterable from typing import","median, unique... depending on the input method. Parameters ---------- method: str, optional The","parameter 'name' must not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn","\"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","Draws the Bar Chart of the input vColumns based on an aggregation. \"\"\"","represents the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :","'cat_stats'. Returns ------- tablesample An object containing the result. For more information, see","[\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]), ] )","] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"]","OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: avg, stddev =","trans += \"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \".format( \"{}\", result[i","1) query = \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query","If set to True, NULL values will not be considered during the computation.","return self.aggregate([\"min\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int =","return the transformation used instead of the parent vDataFrame. This parameter is used","avg(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average","Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the","\"({} - {}) / ({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({}","the data when 'ts' is lesser than November 1993 the 3rd. end_date: str","[name] all_new_features += [name] conj = \"s were \" if len(all_new_features) > 1",") if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self,","vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the","AS count\" \" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0}","return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) #","list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the","used for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers :","{})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column = \"DECODE({}, NULL, 0, 1)\" elif","self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND","to use a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations )","end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \"\"\" ---------------------------------------------------------------------------","use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\",","q Quantile of the vColumn 'of' (ex: 50% to get the median). It","based on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [","vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also --------","/ / # _____________ / / # \\ / / / # \\","self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt = kurtosis # ---#","max_cardinality: int = 6, h: float = 0, pie_type: str = \"auto\", ax=None,","start_date: str / date, optional Input Start Date. For example, time = '03-11-1993'","transformed. Parameters ---------- start: int Start of the slicing. step: int Size of","can drastically decrease. Returns ------- float quantile (or approximate quantile). See Also --------","[str, datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int,","], ), (\"x\", x, [int, float]), ] ) if func not in (\"log\",","See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based on","if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title = \"Reads","used in the partition. order_by: list, optional List of the vColumns to use","lp, rp = \"\", \"\" for category in cat: tmp_query = \"\"\"SELECT '{0}'","the input number of digits after the comma. Parameters ---------- n: int Number","column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY","- index_start if limit <= 0: limit = 0 limit = \" LIMIT","self.alias), self.alias, kwargs[\"agg\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\"Computing the distinct","add_history, [bool])]) try: parent = self.parent force_columns = [ column for column in","Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart of","[self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from","std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%',","optional Uses the Gaussian distribution to identify outliers. After normalizing the data (Z-Score),","in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"]","(elem[0] == None) else \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) ) result[idx][1] = \"NULL\" if (elem[1] ==","discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the","the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate",") # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard","if elem[1] != None ] ), ) cmax = \"DECODE({}, {}, NULL)\".format( by[0],","= ( \"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}'","from verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut, rose,","END odd : CASE ... WHEN vColumn = argv[2 * i] THEN argv[2","optional If set to True, NULL values will not be considered during the","# Methods # # ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \"\"\" return self.transformations[-1][2]","self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({}","str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for the regular","is in each of the vColumn records. vDataFrame[].str_count : Computes the number of","expr = \"CASE WHEN \" + \" WHEN \".join(conditions) + \" END\" self.apply(func=expr)","outliers by the NULL value. winsorize : Clips the vColumn using as lower","\\ \\ \\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\","BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\" ).format(self.alias, max_cardinality","expression in each record of the vColumn. The vColumn will be transformed. Parameters","|| ''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or ( self.isnum()","h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset: int","else \" DESC\" partition_by = ( \"PARTITION BY {}\".format( \", \".join([quote_ident(column) for column","# Modules # # Standard Python Modules import math, re, decimal, warnings, datetime","== \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values: for i","ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query","the 3rd. area: bool, optional If set to True, draw an Area Plot.","vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes","vColumn. Parameters ---------- limit: int, optional Number of elements to display. Returns -------","histogram nbins using Random Forest.\", method=\"fetchall\", ) result = [elem[0] for elem in","{}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result]","the vColumn records. vDataFrame[].str_count : Computes the number of matches for the regular","the first element (Constant Interpolation). mean : Average. median : median. mode :","trans = (\"{} || ''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\")","pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---#","n)) # ---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard","nbins <= 0: h = self.numh() else: h = (self.max() - self.min()) *","( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {}","-threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0] + result[\"avg\"][0], ) else: query","else \"\" if (h > 1) or (self.category() == \"float\"): trans = (","the average of the {}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\", )","must be numerical to use a mean encoding\" ) max_floor = len(self.parent[response].transformations) -","**style_kwds) # ---# def boxplot( self, by: str = \"\", h: float =","vColumn using the mean encoding of a response. \"\"\" import verticapy.stats as st","otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to train a Random Forest with","( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog:","topk_percent : kth most occurent element density unique : cardinality (count distinct) var","range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date]","Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique... depending on","by keeping only the input number of digits after the comma. Parameters ----------","self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL(","6) else \"mode\" total = self.count() if (method == \"mode\") and (val ==","element to use to order the data\" ) desc = \"\" if (method","\"\"\" check_types([(\"limit\", limit, [int, float]), (\"offset\", offset, [int, float])]) if offset < 0:","vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object","expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store","return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn","h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart","/ / # ______ / / # \\ / / / # \\","= 0, h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","specified name. \\u26A0 Warning : SQL code generation will be slower if the","IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE","else \"AVG\" if by == []: if fun == \"AVG\": val = self.avg()","{}.\".format( self.alias, dtype ) ) return self.parent except Exception as e: raise ConversionError(","sub(self, x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters","# # # Modules # # Standard Python Modules import math, re, decimal,","dict, optional Method to use to impute the missing values. auto : Mean","WHERE {} IS NOT NULL \".format(self.alias) if (dropna) else \" \" result =","median. mode : mode (most occurent element). 0ifnull : 0 when the vColumn","{} FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER BY","by]) ) if (by) else \"\" ) order_by_ts = \", \".join([quote_ident(column) + desc","statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","/ # \\ / / / # \\ / / / # \\/","check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) #","WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where,","tuple, optional Tuple including the 2 quantiles used to draw the Plot. start_date:","(\"log\", \"mod\", \"pow\", \"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(),","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average See","Looks if some specific records are in the vColumn and it returns the","all_new_features = [] prefix = ( self.alias.replace('\"', \"\") + prefix_sep.replace('\"', \"_\") if not","self.iloc(limit=limit) # ---# def hist( self, method: str = \"density\", of: str =","self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn","\"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: cmax, cmin","elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif","category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random","must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if","head of the vColumn. \"\"\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k:","Also -------- vDataFrame.donut : Draws the donut chart of the vColumn based on","Chart of vColumn based on an aggregation. \"\"\" check_types( [ (\"method\", method, [str]),","Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable from typing","affiliates. # Licensed under the Apache License, Version 2.0 (the \"License\"); # You","copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {}","Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std See Also","and max). (x - min) / (max - min) by: list, optional vColumns","|_ |~) _ _| _ /~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| #","discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the","self.alias, self.transformations = ( parent, alias, [elem for elem in transformations], ) self.catalog","example, to check if Badr and Fouad are in the vColumn. You can","if val == None: warning_message = \"The vColumn {} has no mode (only","and the values higher than the upper bound to the upper bound itself.","Draws the Time Series of the vColumn. Parameters ---------- ts: str TS (Time","is null, 1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns","data\" ) desc = \"\" if (method in (\"ffill\", \"pad\")) else \" DESC\"","response = self.parent.format_colnames(response) drop(tmp_view_name, method=\"view\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, )","of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method,","the vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if","{} WHERE {} IS NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias","value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the","fun == \"AVG\": val = self.avg() elif fun == \"MEDIAN\": val = self.median()","[order_by] check_types( [ ( \"method\", method, [ \"auto\", \"mode\", \"0ifnull\", \"mean\", \"avg\", \"median\",","to name the new categories. If empty, names will be generated. include_lowest: bool,","self.category() == \"int\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self,","an aggregation. Parameters ---------- method: str, optional The method to use to aggregate","distribution to define the outliers. After normalizing the data (Z-Score), if the absolute","= gen_cmap()[0] else: if not (\"color\" in kwargs): from verticapy.plot import gen_colors kwargs[\"color\"]","ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date, [str, datetime.datetime, datetime.date, int, float],","int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start","TS field from the vColumn (only if the vColumn type is date like).","the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if the",") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns","FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(),","Response vColumn. nbins: int, optional Maximum number of nbins used for the discretization","iloc(self, limit: int = 5, offset: int = 0): \"\"\" --------------------------------------------------------------------------- Returns a","axes. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any",") warnings.warn(warning_message, Warning) return self elif method == \"minmax\": if n == 0:","check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype = get_data_types( \"SELECT {}","vColumn based on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types(","datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)","setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s","{} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit,","\"donut\" else False rose = True if pie_type == \"rose\" else False if","(\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]),","= [self.alias] check = True if len(args) > 0: column = args[0] elif","a function to the vColumn. \"\"\" check_types( [ ( \"func\", func, [ \"abs\",","# ______ / / # \\ / / / # \\ / /","check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format( \"{}\", to_replace.replace(\"'\",","to an aggregation. vColumns will memorize the already computed aggregations to gain in","[self.min()] + result + [self.max()] elif method == \"topk\": assert k >= 2,",": number raised to the power of another number round : rounds a","vColumn record by an input value. The vColumn will be transformed. Parameters ----------","(\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol, [str]),","else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end )","func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) )",") query = \"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS","str : List of the different transformations. \"\"\" # # Special Methods #","abs : absolute value acos : trigonometric inverse cosine asin : trigonometric inverse","if not (h) or h <= 0: if nbins <= 0: h =","not (prefix) else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n = 1 if","self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q,","with 20 trees and a maximum depth of 10. response: str, optional Response","self.alias: [top]} ) return top # ---# def mul(self, x: float): \"\"\" ---------------------------------------------------------------------------","= \"(\", \")\" else: lp, rp = \"\", \"\" for category in cat:","[ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[2] if","\"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int, float]), ] ) if","vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \"\"\" check_types([(\"limit\", limit, [int,","information. Parameters ---------- k: int, optional Number of most occurent elements to return.","size to convert to use to convert the vColumn. If this parameter is",") return self.parent except Exception as e: raise ConversionError( \"{}\\nThe vColumn {} can","method: str = \"zscore\", by: list = [], return_trans: bool = False ):","the regular expression is in each of the vColumn records. The vColumn will","+= [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"] result.values[\"woe\"] +=","GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY","= self.aggregate([\"mad\", \"approx_median\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return","k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv =","({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops","the input method. Parameters ---------- method: str, optional The describe method. auto :","-------- vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name =","{} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method:","optional Labels used to name the new categories. If empty, names will be","\"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of the vColumn","\\_____\\ \\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/","[], include_lowest: bool = True, right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes","Catalog where each key corresponds to an aggregation. vColumns will memorize the already","upper=p_1_alpha) elif method == \"null\": self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {})","result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the","---# def mad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation).","method != \"robust_zscore\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) >","p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in","self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\"Different aggregations to","conj = \"s were \" if total > 1 else \" was \"","check_types([(\"dtype\", dtype, [str])]) try: query = \"SELECT {}::{} AS {} FROM {} WHERE","query_result = executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result","# ---# def apply(self, func: str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies","be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn","def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters","category, ctype = \"float\", \"float\" elif method == \"0ifnull\": category, ctype = \"int\",","---# def spider( self, by: str = \"\", method: str = \"density\", of:","vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the input expression.","(\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ] ) assert self.isnum()","\"categorical\") ): query = \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY","Returns ------- float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\",","end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts)","in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by if method in [\"ffill\",","limit, [int, float]), (\"offset\", offset, [int, float])]) if offset < 0: offset =","the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use to","will be one of the following: date / int / float / text","partition. order_by: list, optional List of the vColumns to use to sort the","or ( self.isnum() and method == \"smart\" ): n = len(result) trans =",") return self.parent except Exception as e: raise QueryError( \"{}\\nError when applying the","= method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]),","[str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A","1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1","self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var'","- 1], result[i], result[i - 1], result[i] ) trans += \" ELSE NULL","first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses","vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate","self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter( \"ABS({} - {}) / {} < {}\".format( self.alias, result[\"avg\"][0], result[\"std\"][0],","trigonometric cotangent exp : exponential function floor : value down to the next","title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result): result[idx][0] =","a Z-Score - The Standard Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning)","(numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"), TypeError( \"The","self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values: for i in range(len(values[elem])): if","[ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\"color\"], lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines,","FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset,","title=\"Testing the Type casting.\") self.transformations += [ ( \"{}::{}\".format(\"{}\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), )","vColumn. \"\"\" check_types([(\"x\", x, [int, float])]) assert x != 0, ValueError(\"Division by 0","vDataFrame.eval : Evaluates a customized expression. \"\"\" check_types([(\"name\", name, [str])]) name = quote_ident(name.replace('\"',","GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\".format( alpha, self.alias, alpha,","Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" check_types([(\"n\",","dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations += [","---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # #","self.__dict__[attr] = val # # Methods # # ---# def aad(self): \"\"\" ---------------------------------------------------------------------------","column = args[0] elif \"column\" in kwargs: column = kwargs[\"column\"] else: check =",") result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\")","aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to","LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\")","\"{}\", \", \".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format(","float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If set to","def str_replace(self, to_replace: str, value: str = \"\"): \"\"\" --------------------------------------------------------------------------- Replaces the regular","title=\"Computing the optimized histogram nbins using Random Forest.\", method=\"fetchall\", ) result = [elem[0]","fun = \"APPROXIMATE_MEDIAN\" query = \"SELECT {}, {}({}) FROM {} GROUP BY {};\".format(","= True, use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with","vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"], self.alias: [store_usage]} ) return store_usage #","--------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset and a","0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor","\"\", stddev ), \"float\", \"float\", ) ] elif method == \"robust_zscore\": if n","datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ]","+= self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit =","the alias of one of the dummies ({name}).\\n\" \"It can be the result","max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL(","Sum of the vColumn 'of'. q% : q Quantile of the vColumn 'of'","greater or equal to 1\") where = \" WHERE {} IS NOT NULL","Forest.\", method=\"fetchall\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\")","return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str = \"density\", of: str","self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\" if","BY {})\".format( self.alias, \", \".join(by) ), ) else: avg, stddev = ( \"AVG({})","elif n == 1: try: result = executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM","h will be picked or computed) h: float, optional Interval width of the","using the Robust Z-Score (median and mad). (x - median) / (1.4826 *","input aggregations. \"\"\" return self.aggregate([\"sem\"]).values[self.alias][0] # ---# def skewness(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length:","the different aggregation. aad : average absolute deviation approx_unique : approximative cardinality count","---# def str_slice(self, start: int, step: int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The","result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0],","int = 6, numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn",") result = executeSQL( query=query, title=\"Computing the optimized histogram nbins using Random Forest.\",","[str])]) return self.apply( func=\"REGEXP_COUNT({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_extract(self, pat:","Uses the threshold instead of the 'alpha' parameter. alpha: float, optional Number representing","bins with the same number of elements. same_width : Computes regular width bins.","= 1, len(by) if self.isbool(): warning_message = \"Normalize doesn't work on booleans\".format(self.alias) warnings.warn(warning_message,","[bool]), (\"threshold\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values","is in each of the vColumn records. The vColumn will be transformed. Parameters","Frequency discretization\" ) total, query, nth_elems = nb, [], [] while total <","order_by: list, optional List of the vColumns to use to sort the data","--------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ---------- method: str,",".values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent","transformation must be similar to the following: (function, type, category) parent: vDataFrame, optional","aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to use to","mean encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params, [dict]), (\"return_enum_trans\", return_enum_trans,","Parameters ---------- x: float A float between 0 and 1 that represents the",") # ---# def rename(self, new_name: str): \"\"\" --------------------------------------------------------------------------- Renames the vColumn by","* FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title = \"Describes","quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use to order","if (h > 1) or (self.category() == \"float\"): trans = ( \"'[' ||","self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if method ==",": Extracts a specific TS field from the vColumn. \"\"\" check_types( [ (\"length\",","method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int",": Verifies if the regular expression is in each of the vColumn records.","------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a","Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize","fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h = max(math.floor(best_h), 1)","usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\"","== \"rose\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import","( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result}) for elem in values:","date, optional Input End Date. For example, time = '03-11-1993' will filter the","new_name.replace('\"', \"\") assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias {new_name}.\\nBy","numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose()","!= None else \"NULL\", ) for elem in result if elem[2] != None","vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use to order","plot_median: bool, optional If set to True, the Median will be drawn. ax:","is set to 'cat_stats'. Returns ------- tablesample An object containing the result. For","tangent tanh : hyperbolic tangent x: int/float, optional If the function has two","], ), (\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ] )","method == \"0ifnull\": category, ctype = \"int\", \"bool\" else: category, ctype = self.category(),","\"({} - {}) / {}({})\".format( \"{}\", avg, \"NULLIFZERO\" if (nullifzero) else \"\", stddev","def normalize( self, method: str = \"zscore\", by: list = [], return_trans: bool","query=query, title=\"Computing the average of the {}'s lower and upper outliers.\".format( self.alias ),","\"Describes the statics of {} partitioned by {}.\".format( numcol, self.alias ) values =","Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using","{})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ) else: final_transformation","DECADE / DOQ / DOW / DOY / EPOCH / HOUR / ISODOW","/ MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER /",") except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor):","/ / / # \\_______/ / / # ______ / / # \\","int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame","for the regular expression in each record of the vColumn. vDataFrame[].extract : Extracts","vDataFrame[].extract : Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace","0ifnull : 0 when the vColumn is null, 1 otherwise. expr: str, optional","0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0:","\"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns -------","+= [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed","FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT","object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head","Note: Dropping a vColumn can make the vDataFrame \"heavier\" if it is used","h, ax=ax, **style_kwds, ) # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","[int(item[1]) for item in result], \"percent\": [float(round(item[2], 3)) for item in result], }","computation. cat_stats : Computes statistics of a numerical column for each vColumn category.","optional Returns the transformation instead of the vDataFrame parent and do not apply","UNION ALL \".join(query), nbins - 1 ) result = executeSQL( query=query, title=\"Computing the","start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median:","{} IN ({}) THEN {} || '' ELSE '{}' END)\".format( bin_spatial_to_str(self.category()), \", \".join(","or equals to 2 in case of discretization using the method 'smart'.\" )","the vColumn. abs : absolute value acos : trigonometric inverse cosine asin :","self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def add_copy(self, name: str): \"\"\" --------------------------------------------------------------------------- Adds","AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {})","self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\", self.alias) query = \"SELECT {}","numerical (except ints and bools), a RF Classifier otherwise. Example: Write {\"n_estimators\": 20,","as e: raise QueryError( \"{}\\nError when applying the func 'x -> {}' to","self.isnum() and method == \"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema =","8, \"nbins\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query =","] if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha == None: mean_alpha","kernel, [\"gaussian\", \"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]),","check_types([(\"lower\", lower, [float, int]), (\"upper\", upper, [float, int])]) assert (lower != None) or","compute other vColumns. Parameters ---------- add_history: bool, optional If set to True, the","func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to","Returns ------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk :","vDataFrame memory usage. \"\"\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) +","of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts","sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number","information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \"\"\" columns =","box plot. The other categories will be filtered. ax: Matplotlib axes object, optional","non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))","the vDataFrame memory usage. \"\"\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias)","\"zscore\": if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias]","\"\"\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func: str","nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \"\",","datetime.datetime, datetime.date] = \"\", plot_median: bool = False, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self,","are in the vColumn and it returns the new vDataFrame of the search.","float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","than the threshold, it will be considered as an outlier. use_threshold: bool, optional","sauv[\"count\"] self.catalog[\"percent\"] = ( 100 * sauv[\"count\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__(","executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent,","def nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn","be empty in case of discretization using the method 'smart'.\" ) self.parent.are_namecols_in(response) response","query, ) title = \"Computing WOE & IV of {} (response = {}).\".format(self.alias,","ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH","like. Optimized h will be computed if the parameter is empty or invalid.","(method == \"categorical\") ): query = \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table","instead of the vDataFrame parent and do not apply it. This parameter is","method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]),","the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \"\"\" check_types([(\"limit\", limit,","the values higher than the upper bound to the upper bound itself. Parameters","the vColumn. The category will be one of the following: date / int","method in (\"mean\", \"median\") or isinstance(val, float): category, ctype = \"float\", \"float\" elif","50% for the median) prod : product range : difference between the max","-------- vDataFrame.plot : Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]),","\"numh is only available on type numeric|date\" ) if self.isnum(): result = (","rule. Parameters ---------- val: int/float/str, optional Value to use to impute the vColumn.","\"date\" # ---# def isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some","[int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \"top\") if pre_comp !=","learning and scoring phases. xlim: tuple, optional Set the x limits of the",") else: query = \"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (),","{}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0],","type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also","cmin, ) else: final_transformation = [ ( \"({} - {}) / {}({} -","isinstance(val, str): val = val.replace(\"'\", \"''\") if val != None: new_column = \"COALESCE({},","== [0, 1], TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) )","self.apply(func=\"{} / ({})\".format(\"{}\", x)) # ---# def drop(self, add_history: bool = True): \"\"\"","h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot","self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} smallest elements.\".format(n, self.alias)","prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of","float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x:","\"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return self.parent # ---# def distinct(self,",": hyperbolic tangent x: int/float, optional If the function has two arguments (example,","‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful graphical options.","if (is_date) and not (method == \"categorical\"): result = self.aggregate([\"count\", \"min\", \"max\"]) index","= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"]","title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] +","quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to False else","from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import *","vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the","in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except","the parent vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame","optional Set the x limits of the current axes. ax: Matplotlib axes object,","BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count","): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation.","statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk = \"\" if","to replace. value: str, optional New value. Returns ------- vDataFrame self.parent See Also","the approximate median is returned. By setting this parameter to False, the function's","ParameterError( \"numh is only available on type numeric|date\" ) if self.isnum(): result =","except: new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \",","* from verticapy.errors import * ## # # __ __ ______ ______ __","\"\"\" # # Special Methods # # ---# def __init__( self, alias: str,","rp = \"(\", \")\" else: lp, rp = \"\", \"\" for category in","trans = self.discretize( method=\"same_width\" if self.isnum() else \"topk\", nbins=nbins, k=nbins, new_category=\"Others\", return_enum_trans=True, )[0].replace(\"{}\",","1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND {})\".format(self.alias,","more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive",")[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines +=","[int, float]), (\"pie_type\", pie_type, [\"auto\", \"donut\", \"rose\"]), ] ) donut = True if","If the function has two arguments (example, power or mod), 'x' represents the","ZScores. threshold: float, optional Uses the Gaussian distribution to define the outliers. After","bool = True, right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn","100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER","mode) topk_percent : kth most occurent element density unique : cardinality (count distinct)","= self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(),","vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by =","float optimal bar width. \"\"\" check_types( [(\"method\", method, [\"sturges\", \"freedman_diaconis\", \"fd\", \"auto\"])] )","Parameters ---------- field: str The field to extract. It must be one of","limit = \" LIMIT {}\".format(limit) else: limit = \"\" query = \"(SELECT {}",": average median : median min : minimum mode : most occurent element","check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]),","following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame","cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt :","mean : Replaces the upper and lower outliers by their respective average. null","order_by_ts = \", \".join([quote_ident(column) + desc for column in order_by]) new_column = \"COALESCE({},","vColumn using the mean encoding of a response. \"\"\" if self.category() in [\"date\",","optional Tuple including the 2 quantiles used to draw the Plot. start_date: str","if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for elem in copy_trans] for","IV of {} (response = {}).\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\"index\"] +=","matches for the regular expression in each record of the vColumn. vDataFrame[].extract :","Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of points","Input Start Date. For example, time = '03-11-1993' will filter the data when","MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n","(start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end","be picked or computed) nbins: int, optional Number of nbins. If empty, an","None): val = self.mode(dropna=True) if val == None: warning_message = \"The vColumn {}","nb != 0, Exception( \"Not enough values to compute the Equal Frequency discretization\"","Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\")","str, optional vColumn to use to partition the TS. start_date: str / date,","max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None, None),","in sauv: self.catalog[\"count\"] = int(sauv[\"count\"]) + total self.catalog[\"percent\"] = ( 100 * (int(sauv[\"count\"])","self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \"({} BETWEEN {} AND","\"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\"float\", \"int\"),",": Back Propagation of the next element (Constant Interpolation). ffill : Propagation of","n: int Number of digits to keep after the comma. Returns ------- vDataFrame","self.catalog[elem] = (sauv[elem] - sauv[\"mean\"]) / sauv[ \"std\" ] elif method == \"minmax\":","\"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \"numh","and scoring phases. xlim: tuple, optional Set the x limits of the current","the vColumn by the input element. Parameters ---------- x: float Input number. Returns","> 0.0001: h = round(h, 4) elif h > 0.000001: h = round(h,","bool = True, use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn","Deviation is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n ==","timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles used to","self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed using a mean","the vDataFrame. \"\"\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val]","100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std,","vDataFrame[].ctype : Returns the vColumn database type. \"\"\" return self.transformations[-1][2] # ---# def","range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY","result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i]","'nbins' must be greater or equals to 2 in case of discretization using","(cardinality). Parameters ---------- approx: bool, optional If set to True, the approximate cardinality","to False, the function's performance can drastically decrease. Returns ------- float/str median See","def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str","0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema","be one of the following: date / int / float / text /","else \"\" ) order_by_ts = \", \".join([quote_ident(column) + desc for column in order_by])","{} AND {})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \"\"\"","# ---# def mul(self, x: float): \"\"\" --------------------------------------------------------------------------- Multiplies the vColumn by the","the vColumn. \"\"\" return self.iloc(limit=limit) # ---# def hist( self, method: str =","usage. \"\"\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) +","response. \"\"\" check_types( [ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]),","on data stored in Vertica, taking advantage Vertica’s # speed and built-in analytics",": Computes statistics of a numerical column for each vColumn category. In this","ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP","on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\",","--------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn record by","max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]), ] )","None else \"NULL\", ) for elem in result if elem[1] != None ]","\"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def count(self):","# ---# def drop(self, add_history: bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn","frequency histogram bins.\", method=\"fetchall\", ) result = [elem[0] for elem in result] elif","(\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]), (\"right\", right, [bool]), ]","---------- field: str The field to extract. It must be one of the","\"'{}', {}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr =","op1, op2, close_l, close_r = \"<=\", \"<\", \"[\", \"[\" if idx == 0","cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp","--------------------------------------------------------------------------- Returns the category of the vColumn. The category will be one of","self.apply(func=\"{} - ({})\".format(\"{}\", x)) # ---# def sum(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","trans += \" ELSE NULL END)\" trans = (trans, \"varchar\", \"text\") if return_enum_trans:","the data. count : Number of elements. density : Percentage of the distribution.","def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float","\".join(by) ), \"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if","part of the DB version you are using. Returns ------- tablesample An object","optional vColumn to use to partition the data. bandwidth: float, optional The bandwidth","decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\"index\": [\"top{}\".format(n)], self.alias: [top]} ) return top #","(\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int, float]), ] )","* i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See","'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can not be empty in case","time = '03-11-1993' will filter the data when 'ts' is lesser than November","vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2)","\"smart\": schema = verticapy.options[\"temp_schema\"] if not (schema): schema = \"public\" tmp_view_name = gen_tmp_name(schema=schema,","|(_(_|| \\/ # / # VerticaPy is a Python library with scikit-like functionality","of: str = \"\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float,","preparing your data. Parameters ---------- new_name: str The new vColumn alias. Returns -------","if (self.isnum() and method == \"same_freq\") or ( self.isnum() and method == \"smart\"","Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]), (\"max_cardinality\", max_cardinality, [int, float]),","to be used as categorical (No h will be picked or computed) ax:","/ NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events =","{})\".format( self.alias, \", \".join(by) ), ) if return_trans: return \"({} - {}) /","0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except: ctype = get_data_types( \"SELECT","in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True,","\"_\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes","def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime,","of the different categories to consider when drawing the box plot. The other",": minimum mode : most occurent element percent : percent of non-missing elements","- {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else: warning_message =","------- bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool :","+ nth_elems + [str(count)]) ) query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER()","== \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] )","cardinality (count distinct) var : variance Other aggregations could work if it is",") ) else: raise TypeError(\"The vColumn must be numerical for Normalization\") return self.parent","(trans, \"varchar\", \"text\") if return_enum_trans: return trans else: self.transformations += [trans] sauv =","using 'median'. Parameters ---------- approx: bool, optional If set to True, the approximate","multiple times, so it's better practice to use this method when first preparing","number of seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent","(\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by)","geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib","vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the","if (method in (\"ffill\", \"pad\")) else \" DESC\" partition_by = ( \"PARTITION BY","True, the approximate quantile is returned. By setting this parameter to False, the","to True, the information will be stored in the vDataFrame history. Returns -------",": Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product #","if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else: return self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method:","isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by,","closed. If set to True, the intervals will be closed on the right.","a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn","column in enumerate(columns): param = {\"color\": colors[idx % len(colors)]} ax = self.parent.search( \"{}","# ---# def round(self, n: int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping","Also -------- vDataFrame[].slice : Slices the vColumn using a time series rule. \"\"\"","catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert","\"\"\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x: float","str = \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date]","input method. Parameters ---------- method: str, optional The method to use to discretize","vDataFrame : Parent of the vColumn. transformations, str : List of the different","/ /\\ ___\\ /\\ __ \\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./","index_start if limit <= 0: limit = 0 limit = \" LIMIT {}\".format(limit)","vColumn distinct elements to be used as categorical. The less frequent elements will","for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv","\" was \" if verticapy.options[\"print_info\"]: print(\"{} element{}filled.\".format(total, conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing","\"percent\": 100.0, \"unique\": 2, \"approx_unique\": 2, \"prod\": 0, }, ) setattr(self.parent, name, new_vColumn)","---------- method: str, optional Method to use to compute the optimal h. auto","Applies a default function to the vColumn. Parameters ---------- func: str Function to","be transformed. Parameters ---------- start: int Start of the slicing. step: int Size","'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the","float, optional The interval size to convert to use to convert the vColumn.","FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \"SELECT {},","query = \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS","partition. return_trans: bool, optimal If set to True, the method will return the","skew = skewness # ---# def slice(self, length: int, unit: str = \"second\",","{} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {}","missing values. auto : Mean for the numerical and Mode for the categorical","of using previously the method on the vColumn \" \"or simply because of","\\ \\____ \\ \\ \\_\\ \\ \\ \\ \\-./\\ \\ \\ \\ \\-.","-------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes","return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) #","end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts)","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\",","[self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot","density unique : cardinality (count distinct) var : variance Other aggregations could work","\"Parameter 'response' can not be empty in case of discretization using the method","{}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax,","transformed with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) )","dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops","the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.","# ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean,","0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS","= ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025,","(method == \"categorical\")) or ( method == \"is_numeric\" ): self.parent.__update_catalog__({\"index\": index, self.alias: result})","self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \"\"\" ---------------------------------------------------------------------------","------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the","self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else:","method. Parameters ---------- method: str, optional Method to use to normalize. zscore :","MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ),","* ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\".format(","False else the lower and upper ZScores. threshold: float, optional Uses the Gaussian","auto : Uses method 'same_width' for numerical vColumns, cast the other types to","if the regular expression is in each of the vColumn records. The vColumn","self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp assert self.isnum() or self.isdate(), ParameterError(","Draws the Box Plot of the input vColumns. \"\"\" if isinstance(cat_priority, str) or","self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \"SELECT {} FROM (SELECT","the n smallest elements in the vColumn. Parameters ---------- n: int, optional Offset.","FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha,","AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM","\"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int, optional","= 200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the","vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory","method: str = \"winsorize\", threshold: float = 4.0, use_threshold: bool = True, alpha:","= False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not","the mode) topk_percent : kth most occurent element density unique : cardinality (count","--------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories to [0,","the vDataFrame input aggregations. \"\"\" check_types([(\"dropna\", dropna, [bool]), (\"n\", n, [int, float])]) if","(\"h\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)","str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a default function to the","\" END\" self.apply(func=expr) # ---# def ctype(self): \"\"\" --------------------------------------------------------------------------- Returns the vColumn DB","ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar Chart","= \"NULL\" if mean_1_alpha == None: mean_alpha = \"NULL\" self.apply( func=\"(CASE WHEN {}","if not (schema): schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple,","[list]), (\"h\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by =","self.apply(func=\"{} * ({})\".format(\"{}\", x)) # ---# def nlargest(self, n: int = 10): \"\"\"","if elem[1] != None ] ), ) stddev = \"DECODE({}, {}, NULL)\".format( by[0],","Increasing this parameter will increase the precision but will also increase the time","= abs(self.count() - total) except Exception as e: self.transformations = [elem for elem",": 'Others'. cat_priority: list, optional List of the different categories to consider when","using the method 'same_freq'\" ) count = self.count() nb = int(float(count / int(nbins)))","END AS woe, CASE WHEN non_events = 0 OR events = 0 THEN","pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query,","self.alias, self.alias, n ) title = \"Reads {} {} largest elements.\".format(self.alias, n) return","normalize.\", method=\"fetchall\", ) for i in range(len(result)): if result[i][2] == None: pass elif","the vColumn (delimited by an offset and a limit). Parameters ---------- limit: int,","spider plot of the input vColumn based on an aggregation. Parameters ---------- by:","{}) VERTICAPY_OPTIMAL_H_TABLE\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \"SELECT COUNT({}) AS NAs,","= \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result","------- ax Matplotlib axes object \"\"\" columns = [self.alias] check = True if","a mean encoding with {} as Response Column.\".format( self.alias, response ) ) if","\"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp store_usage =","/ # _____________ / / # \\ / / / # \\ /","str, optional Slice size unit. For example, it can be 'minute' 'hour'... start:",": trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the function","{})\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters","'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used","import gen_colors kwargs[\"color\"] = gen_colors()[0] if not (\"legend\" in kwargs): kwargs[\"legend\"] = True","use this method when first preparing your data. Parameters ---------- new_name: str The","ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters","= sauv[elem] elif elem == None: self.catalog[elem] = None elif method == \"robust_zscore\":","Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the","(standard error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate :","mean encoding with {} as Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]:","{} OFFSET {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, )","pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---#","= executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY","method.lower() check_types( [ (\"method\", method, [\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\",","int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self):","Replaces the upper and lower outliers by their respective average. null : Replaces","with 0 and 1 (1 meaning global outlier). \"\"\" if isinstance(method, str): method","entire relation, a vColumn can be seen as one column of that relation.","0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4})","minimum mode : most occurent element percent : percent of non-missing elements q%","0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\"max_rows\"])._repr_html_()","count DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH vdf_table AS (SELECT *","warning_message = \"The method 'robust_zscore' is available only if the parameter 'by' is","\"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\":","max(0, self.parent.shape()[0] - limit) title = \"Reads {}.\".format(self.alias) tail = to_tablesample( \"SELECT {}",": Regular pie chart. donut : Donut chart. rose : Rose chart. It","({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else: warning_message = \"Can not normalize","vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def isdate(self):","drawing the box plot. The other categories will be filtered. ax: Matplotlib axes","vDataFrame.memory_usage : Returns the vDataFrame memory usage. \"\"\" import sys total = (","verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds,","optional List of the different transformations. Each transformation must be similar to the","input aggregations. \"\"\" return self.aggregate([\"aad\"]).values[self.alias][0] # ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the","max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5,","\"\", stddev ) else: final_transformation = [ ( \"({} - {}) / {}({})\".format(","lower bound to the lower bound itself and the values higher than the","= \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str):","normalize {} using a Robust Z-Score - The MAD is null !\".format( self.alias","{}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({})","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew =","\"logistic\", \"sigmoid\", \"silverman\"]), (\"bandwidth\", bandwidth, [int, float]), (\"nbins\", nbins, [float, int]), ] )","OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL)","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also","can only have one parent. catalog: dict, optional Catalog where each key corresponds","maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","= '{}', tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i ) for i","len(breaks) == len(labels) + 1 or not (labels), ParameterError( \"Length of parameter breaks","kwargs[\"figsize\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix:","datetime.datetime, datetime.date, int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float],","self.alias, query, ) title = \"Computing WOE & IV of {} (response =","License. # You may obtain a copy of the License at # #","self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", )","= max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name)","result[idx][1] = \"NULL\" if (elem[1] == None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({},","Median will be drawn. ax: Matplotlib axes object, optional The axes to plot","in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---#","a mean encoding\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k","Name of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval :","x: float): \"\"\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ----------","kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute deviation max","final generated SQL code. Note: Dropping a vColumn can make the vDataFrame \"heavier\"","h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of","{}, \"regr_syy\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---#","== 0: warning_message = \"Can not normalize {} using a Z-Score - The","vDataFrame parent and do not apply it. This parameter is very useful for","bins.\", method=\"fetchall\", ) result = [elem[0] for elem in result] elif self.isnum() and","str TS (Time Series) vColumn to use to order the data. The vColumn","of the vColumn (delimited by an offset and a limit). Parameters ---------- limit:","sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt","vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame self.parent See","h: int/float/tuple, optional Interval width of the vColumns 1 and 2 bars. It","was transformed with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), )","> 6) else \"mode\" total = self.count() if (method == \"mode\") and (val","computation. Returns ------- tablesample An object containing the result. For more information, see","first element (Constant Interpolation). mean : Average. median : median. mode : mode","--------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule. Parameters ----------","vColumn to the parent vDataFrame. Parameters ---------- name: str Name of the copy.","of an independent variable in relation to the dependent variable. Parameters ---------- y:","3)) for item in result], } return tablesample(values) # ---# def value_counts(self, k:","Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns","y, query, ) query = \"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events)","The method used for the plot. gaussian : Gaussian kernel. logistic : Logistic","[ (\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]),","optional Interval width if the vColumn is numerical or of type date like.","# ---# def abs(self): \"\"\" --------------------------------------------------------------------------- Applies the absolute value function to the","str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each record of","(Number of non-Missing elements). Returns ------- int number of non-Missing elements. See Also","Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \"\"\" return self.describe(method=\"categorical\", max_cardinality=k)","BY _verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, )","Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional","transformations], ) self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {},",": hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor :","self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is only available for categorical","of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int =","cmin, \"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", ) ]","* mad) minmax : Normalization using the MinMax (min and max). (x -","op2, close_l, close_r = \"<\", \"<=\", \"]\", \"]\" else: op1, op2, close_l, close_r","elif idx == 0: op1, close_l = \"<\", \"]\" if labels: label =","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.quantile(0.5,","50): try: result = executeSQL( \"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY","values lesser than the lower bound to the lower bound itself and the","query = \"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY","by = [by] check_types( [ (\"method\", method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]),","offset: int, optional Number of elements to skip. Returns ------- tablesample An object","self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be numerical",": Clips the vColumn using as lower bound quantile(alpha) and as upper bound","FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\"","where, self.alias, n ), title=\"Computing the mode.\", method=\"fetchall\", ) top = None if","the vColumn. labels: list, optional Labels used to name the new categories. If","Encodes the vColumn with One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response =","be included. right: bool, optional How the intervals should be closed. If set","end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool = False, step: bool =","[trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])","\" \"or simply because of ambiguous columns naming.\\nBy changing one of \" \"the","by[0], ), title=\"Computing the different categories {} to normalize.\".format( by[0] ), method=\"fetchall\", )","= 0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) *","'name', you'll be able to solve this issue.\" ) new_vColumn = vColumn( name,","not in kwargs: query = \"SELECT {} AS {} FROM {} WHERE {}","smallest elements in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT","by: str, optional vColumn to use to partition the data. h: float, optional","True if the vColumn category is date. \"\"\" return self.category() in (\"float\", \"int\")","result of using previously the method on the vColumn \" \"or simply because",": Normalization using the Robust Z-Score (median and mad). (x - median) /","---# def str_contains(self, pat: str): \"\"\" --------------------------------------------------------------------------- Verifies if the regular expression is","= [ ( \"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", )","a response. \"\"\" if self.category() in [\"date\", \"float\"]: warning_message = ( \"label_encode is","optional Value to use to impute the vColumn. method: dict, optional Method to","quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers :","return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---#","series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\", start_date,","response. \"\"\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\"{}\"), *argv)) # ---# def density(","int): \"\"\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of","inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt","equal to 2.\" ) assert len(breaks) == len(labels) + 1 or not (labels),","lw=4, ), ] ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], )","The other categories will be filtered. ax: Matplotlib axes object, optional The axes","# \\ / # \\ / # \\/ # _ # \\ /","Uses the Random Forest on a response column to find the most relevant","-------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns the","str The new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy","collections.abc import Iterable from typing import Union # VerticaPy Modules import verticapy from","= \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2}","+ [item[1] for item in query_result] index = [\"unique\", \"count\"] + [item[0] for","self.catalog[\"mad\"] = 1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"]","False otherwise. Returns ------- bool True if the vColumn is boolean. See Also","= max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category() == \"int\": best_h =","matches in each of the vColumn records by an input value. vDataFrame[].str_slice :","if the regular expression is in each of the vColumn records. vDataFrame[].str_count :","self.ctype()] + result, } if ((is_date) and not (method == \"categorical\")) or (","added to the vDataFrame.\".format( self.alias, name ) ) return self.parent # ---# def","can be the result of using previously the method on the vColumn \"","order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor","range(max_floor): self.parent[copy_name].transformations += [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)]","\"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias, conj, ) ) else: if","split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL","self.nunique(True) > 6) else \"mode\" total = self.count() if (method == \"mode\") and","FROM {} LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin","bar chart of the vColumn based on an aggregation. Parameters ---------- method: str,","the vDataFrame input aggregations. \"\"\" check_types( [ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]),","(\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [list]), (\"h\", h, [list, float, int]), ] )","item in result], \"count\": [int(item[1]) for item in result], \"percent\": [float(round(item[2], 3)) for","drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name)","[str])]) try: try: ctype = get_data_types( \"SELECT {} AS apply_test_feature FROM {} WHERE","expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ] ) method = method.lower()","the vColumn records by an input value. \"\"\" check_types([(\"start\", start, [int, float]), (\"step\",","\"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[2] if elem[2] != None","(len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\": fun","check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def sem(self): \"\"\"","self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\"Computing the different categories {} to normalize.\".format( by[0]","WHEN {} < {} THEN {} WHEN {} > {} THEN {} ELSE","0 self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with the","mean skewness : skewness sum : sum std : standard deviation topk :","bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds","= [\"DECODE({}\"] text_info = \"\\n\" for k in range(len(distinct_elements)): expr += [ \"'{}',","the {}'s lower and upper outliers.\".format( self.alias ), method=\"fetchall\", ) ] if mean_alpha","\"\"\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str, Function","'median'. Parameters ---------- approx: bool, optional If set to True, the approximate median","used instead of the parent vDataFrame. This parameter is used for testing purpose.","method: str = \"density\", of: str = \"\", max_cardinality: Union[int, tuple] = (6,","bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\",","def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns","self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area,","the data. # # # Modules # # Standard Python Modules import math,","MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE","!= None else \"NULL\", elem[2] if elem[2] != None else \"NULL\", ) for","AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events","# \\ / / / # \\ / / / # \\/ /","in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") result","for the regular expression in each record of the vColumn. The vColumn will","the Information Value (IV) Table. \"\"\" check_types([(\"y\", y, [str]), (\"nbins\", nbins, [int])]) self.parent.are_namecols_in(y)","= executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias,","i in range(1, n): trans += \"WHEN {} BETWEEN {} AND {} THEN","(h > 1) or (self.category() == \"float\"): trans = ( \"'[' || FLOOR({}","vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return self.ctype().lower() in","Information Value (IV) / Weight Of Evidence (WOE) Table. It tells the predictive","+= self.parent.shape()[0] query = \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias,","of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self,","Apache License, Version 2.0 (the \"License\"); # You may not use this file","self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\"model\") if self.parent[response].category() ==","vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn","--------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory usage (byte)","AS {} FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER","as Response Column.\".format( self.alias, response ) ) if verticapy.options[\"print_info\"]: print(\"The mean encoding was","floor_end = -1 if (self.category() == \"int\") else \"\" if (h > 1)","Rounds the vColumn by keeping only the input number of digits after the","testing to be able to look at the final transformation. Returns ------- vDataFrame","or (upper != None), ParameterError( \"At least 'lower' or 'upper' must have a","(Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes","{}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1 )","str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\"by\", by, [str]),",") desc = \"\" if (method in (\"ffill\", \"pad\")) else \" DESC\" partition_by","([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\"',","[item[0] for item in query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False","MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME ZONE /","available on type numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias],","\"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold * result[\"std\"][0]","/ DECADE / DOQ / DOW / DOY / EPOCH / HOUR /","self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False,","+= [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {}","10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \"\",","\"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\"","method 'same_freq'\" ) count = self.count() nb = int(float(count / int(nbins))) assert nb","h will be picked or computed) ax: Matplotlib axes object, optional The axes","/~\\ _ |. # |_)\\/ |_)(_|(_|| \\_/|_|(_||| # / # ____________ ______ #","result[i], result[i - 1], result[i] ) trans += \" ELSE NULL END)\" trans","Draws the pie chart of the vColumn based on an aggregation. Parameters ----------","optional Uses the Gaussian distribution to define the outliers. After normalizing the data","'Others', SUM(count) FROM (SELECT COUNT(*) AS count\" \" FROM vdf_table WHERE {0} IS","= \"Describes the statics of {} partitioned by {}.\".format( numcol, self.alias ) values","be binary to use iv_woe.\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat ==","if elem[0] != None else \"NULL\", elem[1] if elem[1] != None else \"NULL\",","of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str","alias: str vColumn alias. transformations: list, optional List of the different transformations. Each","named {} was added to the vDataFrame.\".format( self.alias, name ) ) return self.parent","See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \"\"\" check_types([(\"y\",","categorical. numcol: str, optional Numerical vColumn to use when the parameter method is","self.transformations ) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations +=","to normalize.\", method=\"fetchall\", ) for i in range(len(result)): if result[i][2] == None: pass","has no mode (only missing values).\\nNothing was filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return","the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist","(date, datetime ...), the parameter 'x' will represent the number of seconds, otherwise","------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user","\", \".join(by) ), ) else: avg, stddev = ( \"AVG({}) OVER (PARTITION BY","return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad) else: final_transformation = [","k, [int, float]), (\"dropna\", dropna, [bool])]) topk = \"\" if (k < 1)","'categorical' otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats :","vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \"sturges\": best_h","if (dropna) else \"\" query = \"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_,","'{}') > 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat: str): \"\"\"","------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values.","- min) / (max - min) by: list, optional vColumns used in the","# ---# def iv_woe(self, y: str, nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes","in result if elem[1] != None ] ), ) cmax = \"DECODE({}, {},","# ---# def bar( self, method: str = \"density\", of: str = \"\",","for the mode) topk_percent : kth most occurent element density unique : cardinality","total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb","return to_tablesample(query, title=title) # ---# def normalize( self, method: str = \"zscore\", by:","\"[\" elif idx == 0: op1, close_l = \"<\", \"]\" if labels: label","/ # |____/ / / # _____________ / / # \\ / /","the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with","+= [ (\"{}\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog =","index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0","compute the Equal Frequency discretization\" ) total, query, nth_elems = nb, [], []","if (self.isnum() and self.nunique(True) > 6) else \"mode\" total = self.count() if (method","int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where = \"WHERE _verticapy_row_nb_","field: str The field to extract. It must be one of the following:","Returns the distinct categories of the vColumn. Returns ------- list Distinct caterogies of","{}::int AS {} FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query","aggregations. \"\"\" return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn","except: pass total = int(total) conj = \"s were \" if total >","{column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN \"","method is set to 'cat_stats'. Returns ------- tablesample An object containing the result.","query += [lp + tmp_query + rp] query = \"WITH vdf_table AS (SELECT","and 1 (1 meaning global outlier). \"\"\" if isinstance(method, str): method = method.lower()","self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0","(SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY","non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\".format( self.alias, y, y,","used in the partition. return_trans: bool, optimal If set to True, the method","Returns the nth most occurent element. Parameters ---------- dropna: bool, optional If set",") # ---# def product(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns","= ( 100 * (int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass total","\"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \"\"\"","aggregation. Parameters ---------- method: str, optional The method to use to aggregate the","performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See","Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True if the","when 'ts' is lesser than November 1993 the 3rd. end_date: str / date,","] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold","result[7], ) elif self.isdate(): min_date = self.min() table = \"(SELECT DATEDIFF('second', '{}'::timestamp, {})","\\ \\ \\-. \\ # \\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\","as one column of that relation. vColumns simplify several processes with its abstractions.","use this file except in compliance with the License. # You may obtain","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"kurtosis\"]).values[self.alias][0] kurt =","conj)) self.parent.__add_to_history__( \"[Fillna]: {} {} missing value{} filled.\".format( total, self.alias, conj, ) )","self elif method == \"minmax\": if n == 0: nullifzero = 0 cmin,","({}) x GROUP BY 1\".format( self.alias, y, y, query, ) query = \"SELECT","not be considered during the computation. n: int, optional Integer corresponding to the","float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the histogram of the","x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{}","= (self.max() - self.min()) * 1.01 / nbins if h > 0.01: h","invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to be used","bool = True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ----------","OFFSET {}{}) VERTICAPY_SUBTABLE\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index,","vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the","\"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0] != None else \"NULL\", elem[1] if elem[1] != None","+ 1 or parameter 'labels' must be empty.\" ) conditions, column = [],",".replace(\"/\", \"_\") .replace(\",\", \"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format(","int): \"\"\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ----------","{} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent","column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format( self.parent.__genSQL__(force_columns=force_columns)","DESC LIMIT {1})\"\"\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += (","Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \"\"\" check_types( [(\"method\",","return self.aggregate([\"mad\"]).values[self.alias][0] # ---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max'","Returns the n largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query =","box plot of the vColumn. Parameters ---------- by: str, optional vColumn to use","start_or_end = \"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format(","str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes","()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format(","int, optional Number of bins used for the discretization (must be > 1)","vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({}, '{}', '{}')\".format(","nbins: int = 10): \"\"\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight","raise TypeError(\"The vColumn must be numerical for Normalization\") return self.parent # ---# def","\"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ) else: final_transformation = [ (","November 1993 the 3rd. end_date: str / date, optional Input End Date. For","val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and","Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also","parent, vDataFrame : Parent of the vColumn. transformations, str : List of the","'robust_zscore' is available only if the parameter 'by' is empty\\nIf you want to",": Draws the time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by,","\"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\", \"float\", ) ] else: warning_message","\"{}\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \"\"\" --------------------------------------------------------------------------- Converts","of the following: date / int / float / text / binary /",") count = self.count() nb = int(float(count / int(nbins))) assert nb != 0,","and bools), a RF Classifier otherwise. Example: Write {\"n_estimators\": 20, \"max_depth\": 10} to","if the vColumn type is date like). The vColumn will be transformed. Parameters","be created using the input Name. Returns ------- vDataFrame self.parent See Also --------","== 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \"MEDIAN\": fun =","True if the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns","the box plot. The other categories will be filtered. ax: Matplotlib axes object,","computed) nbins: int, optional Number of nbins. If empty, an optimized number of","filled.\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\"'\",","to True, the intervals will be closed on the right. Returns ------- vDataFrame",": Average of the vColumn 'of'. min : Minimum of the vColumn 'of'.","END)\".format( \"{}\", p_alpha, p_1_alpha, \"{}\" ) ) elif method == \"mean\": query =","in result if elem[1] != None ] ), ) stddev = \"DECODE({}, {},","vColumn '{}' was transformed with the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\",","drop(tmp_model_name, method=\"model\") result = [self.min()] + result + [self.max()] elif method == \"topk\":","self.parent.__genSQL__(), \" UNION ALL \".join(query) ) title = \"Describes the statics of {}","p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter(","the number of matches for the regular expression in each record of the","should be closed. If set to True, the intervals will be closed on","start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\",","compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements","[str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts","1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns used in","True, right: bool = True, ): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the","< int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where","= False, n: int = 1): \"\"\" --------------------------------------------------------------------------- Returns the nth most occurent","---------- add_history: bool, optional If set to True, the information will be stored",": absolute value acos : trigonometric inverse cosine asin : trigonometric inverse sine","vColumn using the input functions. Parameters ---------- func: list List of the different","not empty, a copy will be created using the input Name. Returns -------","FROM ({}) x GROUP BY 1\".format( self.alias, y, y, query, ) query =","== \"donut\" else False rose = True if pie_type == \"rose\" else False","vColumn. Parameters ---------- func: str Function to use to transform the vColumn. abs","and mad). (x - median) / (1.4826 * mad) minmax : Normalization using","[xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp,","License. # # |_ |~) _ _| _ /~\\ _ |. # |_)\\/","return best_h # ---# def nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates","item in executeSQL( query=query, title=\"Computing the average of the {}'s lower and upper","pat, [str])]) return self.apply( func=\"REGEXP_SUBSTR({}, '{}')\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_replace(self,","# ---# def div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the","|| FLOOR({} / {}) * {} || ';' || (FLOOR({} / {}) *","if 'use_threshold' is set to False else the lower and upper ZScores. threshold:","--------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns ------- bool","approx_unique : approximative cardinality count : number of non-missing elements cvar : conditional","from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax,","\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {}","[], return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using","\\ \\-. \\ # \\ \\__| \\ \\_____\\ \\ \\_____\\ \\ \\_____\\ \\","/ # \\/ # _ # \\ / _ __|_. _ _ |_)",") self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\": {}, \"spearmand\": {}, \"kendall\":","close_l = \"<=\", \"[\" elif idx == 0: op1, close_l = \"<\", \"]\"","# distributed under the License is distributed on an \"AS IS\" BASIS, #","-------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize :","def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args","# data science projects on data stored in Vertica, taking advantage Vertica’s #","composed of two flower brackets {}. For example to apply the function: x","return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index)","{0} ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\"","\"[\", \"[\" if idx == 0 and include_lowest: op1, close_l = \"<=\", \"[\"","vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing","EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM","{} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY","vColumn type must be date like (date, datetime, timestamp...) or numerical. q: tuple,","e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") ) ) # ---# def apply_fun(self, func: str,","\"bool\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in","use to discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns,","{}\".format(limit) else: limit = \"\" query = \"(SELECT {} FROM {}{} OFFSET {}{})","tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn is","vColumn. labels: list, optional Labels used to name the new categories. If empty,","{})\".format(field, \"{}\")) # ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using","method, [\"zscore\", \"robust_zscore\", \"minmax\"]), (\"by\", by, [list]), (\"return_trans\", return_trans, [bool]), ] ) method","simple: instead of moving # data around for processing, VerticaPy brings the logic","LIMIT 1\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = (","def cut( self, breaks: list, labels: list = [], include_lowest: bool = True,","if fun == \"AVG\": val = self.avg() elif fun == \"MEDIAN\": val =","\\ \\ \\-./\\ \\ \\ \\ \\-. \\ # \\ \\__| \\ \\_____\\","MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query +=","list. Parameters ---------- breaks: list List of values used to cut the vColumn.","assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \"Length of parameter","= \"WITH vdf_table AS (SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), \" UNION ALL","---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See Also","= \"\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top =","p_1_alpha, \"{}\" ) ) elif method == \"mean\": query = \"WITH vdf_table AS","encoding was successfully done.\") return self.parent # ---# def median( self, approx: bool","the vColumn type is date like). The vColumn will be transformed. Parameters ----------","IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result","(\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0,","the function has two arguments (example, power or mod), 'x' represents the second","\"or simply because of ambiguous columns naming.\\nBy changing one of \" \"the parameters","return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent and do","first preparing your data. Parameters ---------- new_name: str The new vColumn alias. Returns","FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY","of: str = \"\", max_cardinality: int = 6, nbins: int = 0, h:","applying the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\")","elem: if \"percent\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem]","query = \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(),","== \"sturges\": best_h = sturges elif method.lower() in (\"freedman_diaconis\", \"fd\"): best_h = fd","else \"\", self.alias ), method=\"fetchall\", ) values = { \"index\": [item[0] for item","user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn","can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also","(SELECT * FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing","best splits when 'method' is set to 'smart'. A RF Regressor will be","= executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result =","The field to extract. It must be one of the following: CENTURY /","{}) / ({})\".format(self.alias, med, mad) else: final_transformation = [ ( \"({} - {})","self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if","self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func) or (","= self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] + result[\"avg\"][0], threshold","self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count() if","Plot. start_date: str / date, optional Input Start Date. For example, time =","= model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise #","columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower()","round(h, 2) elif h > 0.0001: h = round(h, 4) elif h >",": interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad : median","value to a specified number of decimal places sign : arithmetic sign sin","the input list. Parameters ---------- breaks: list List of values used to cut","{} missing value{} filled.\".format( total, self.alias, conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing","parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements","pure SQL used to transform the vColumn. The function variable must be composed","sign sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square","title=\"Computing the Store Usage of the vColumn {}.\".format(self.alias), method=\"fetchfirstelem\", ) self.parent.__update_catalog__( {\"index\": [\"store_usage\"],","of the vColumn record by an input value. The vColumn will be transformed.","-= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\"{}\",","------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the","to get the median). It can also be a cutomized aggregation (ex: AVG(column1)","NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({}","nbins: int = 0, h: float = 0, ax=None, **style_kwds, ): \"\"\" ---------------------------------------------------------------------------","using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is","= gen_tmp_name(schema=schema, name=\"model\") assert nbins >= 2, ParameterError( \"Parameter 'nbins' must be greater","Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name,","max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","quantile (ex: 50% for the median) prod : product range : difference between","set to True, the intervals will be closed on the right. Returns -------","{}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) ) elif method",": Computes regular width bins. smart : Uses the Random Forest on a","= \"SELECT {}, {}({}) FROM {} GROUP BY {};\".format( by[0], fun, self.alias, self.parent.__genSQL__(),","plot( self, ts: str, by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date] =","/ # \\ / # \\ / # \\/ # _ # \\","the upper bound to the upper bound itself. Parameters ---------- lower: float, optional","(tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name,","\"round\"): expr = \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return","verticapy.options[\"print_info\"]: print(\"The mean encoding was successfully done.\") return self.parent # ---# def median(","({} ORDER BY {}))\".format( \"{}\", \"{}\", partition_by, order_by_ts ) if method in (\"mean\",","= \"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {}","the vColumn 'of'. max : Maximum of the vColumn 'of'. sum : Sum","trans = ( \"'[' || FLOOR({} / {}) * {} || ';' ||","vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \"","was added to the vDataFrame.\".format( self.alias, name ) ) return self.parent # ---#",") result = [distinct_count] + result index = [ \"unique\", \"count\", \"mean\", \"std\",","self.alias: result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal):","AS {} FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query =","descriptive statistics. \"\"\" check_types([(\"k\", k, [int, float]), (\"dropna\", dropna, [bool])]) topk = \"\"","optional Maximum number of nbins used for the discretization (must be > 1)","it can be 'minute' 'hour'... start: bool, optional If set to True, the","+ sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the","vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\") assert","---------- to_replace: str Regular expression to replace. value: str, optional New value. Returns","ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name:","look at the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode","ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR","10 logarithm mod : remainder of a division operation pow : number raised","---# def str_extract(self, pat: str): \"\"\" --------------------------------------------------------------------------- Extracts the regular expression in each","to the input vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n))","BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.","\".join(by) ), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else:","optional Numerical vColumn to use when the parameter method is set to 'cat_stats'.","---------- method: str, optional Method to use to normalize. zscore : Normalization using","n ) title = \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title)","more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest","a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required","BY {}\".format( \", \".join([quote_ident(column) for column in by]) ) if (by) else \"\"","vColumn (delimited by an offset and a limit). Parameters ---------- limit: int, optional","int(total) conj = \"s were \" if total > 1 else \" was","sliced using the floor of the slicing instead of the ceiling. Returns -------","(Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean :","mean = avg # ---# def bar( self, method: str = \"density\", of:","response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \"vColumn {} must","query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()]","5): \"\"\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int,","str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes","---------- func: str Function to use to transform the vColumn. abs : absolute","hist( self, method: str = \"density\", of: str = \"\", max_cardinality: int =","(x - median) / (1.4826 * mad) minmax : Normalization using the MinMax","= index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if","parent=self.parent, transformations=transformations, catalog={ \"min\": 0, \"max\": 1, \"count\": self.parent.shape()[0], \"percent\": 100.0, \"unique\": 2,","more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of","each of the vColumn records. vDataFrame[].extract : Extracts the regular expression in each","unit.upper(), start_or_end ) ) # ---# def spider( self, by: str = \"\",","= [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try:","min) by: list, optional vColumns used in the partition. return_trans: bool, optimal If","in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\"'\", \"''\"), ), \"varchar\", \"text\", ) elif self.isnum()","print_time_sql=False, ) except: cmax, cmin = ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias,","QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK /","science projects on data stored in Vertica, taking advantage Vertica’s # speed and","Weight Of Evidence (WOE) Table. It tells the predictive power of an independent","query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) # ---#","will increase the precision but will also increase the time of the learning","Also -------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \"\"\"","of the vColumns 1 and 2 bars. It is only valid if the","\"{}\", p_1_alpha, mean_1_alpha, \"{}\" ) ) return self.parent # ---# def fillna( self,","(or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","Parent of the vColumn. transformations, str : List of the different transformations. \"\"\"","return result except: model.drop() raise # ---# def describe( self, method: str =","str_sql): func = str(func) check_types([(\"func\", func, [str]), (\"copy_name\", copy_name, [str])]) try: try: ctype","\"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list Distinct","offset. For example, if n = 1 then this method will return the","For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n","x ORDER BY ord\".format( self.alias, query, ) title = \"Computing WOE & IV","the method on the vColumn \" \"or simply because of ambiguous columns naming.\\nBy","method to use to aggregate the data. count : Number of elements. density","computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number","values. auto : Mean for the numerical and Mode for the categorical vColumns.","lower, lower) if (isinstance(lower, (float, int))) else \"\" ) upper_when = ( \"WHEN",": Silverman kernel. nbins: int, optional Maximum number of points to use to","# ---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute","distinct categories of the vColumn. Returns ------- list Distinct caterogies of the vColumn.","\"NULLIFZERO\" if (nullifzero) else \"\", cmax, cmin, ), \"float\", \"float\", ) ] if","(ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE","LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format( \" UNION ALL \".join(query), nbins - 1","({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2","NOT NULL GROUP BY {0} ORDER BY COUNT(*)\" \" DESC OFFSET {1}) VERTICAPY_SUBTABLE)","vColumn using the mean encoding of a response. \"\"\" check_types( [ (\"prefix\", prefix,","'{}', '{}')\".format( \"{}\", length, unit.upper(), start_or_end ) ) # ---# def spider( self,","the x limits of the current axes. ax: Matplotlib axes object, optional The","inverse tangent cbrt : cube root ceil : value up to the next","self.apply( func=\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\".format(","sine sqrt : arithmetic square root tan : trigonometric tangent tanh : hyperbolic","in query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias]","The method to use to discretize the vColumn. auto : Uses method 'same_width'","the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx: return self.aggregate(func=[\"approx_unique\"]).values[self.alias][0] else:","/ # VerticaPy is a Python library with scikit-like functionality for conducting #","nbins, [int, float]), (\"h\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of","new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1])","div(self, x: float): \"\"\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters","to use to evaluate the approximate density function. Increasing this parameter will increase","n = 1 if drop_first else 0 for k in range(len(distinct_elements) - n):","\"approx_50%\", \"approx_75%\", \"max\", ] if method != \"cat_stats\": values = { \"index\": [\"name\",","= get_dummies # ---# def head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns","nlargest(self, n: int = 10): \"\"\" --------------------------------------------------------------------------- Returns the n largest vColumn elements.","------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the input","\"_\") .replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\")","\"\" for category in cat: tmp_query = \"\"\"SELECT '{0}' AS 'index', COUNT({1}) AS","[str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts","self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} + ({})\".format(\"{}\", x)) # ---# def","return self.describe(method=\"categorical\", max_cardinality=k) # ---# def var(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using",") if return_trans: return \"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if","slice(self, length: int, unit: str = \"second\", start: bool = True): \"\"\" ---------------------------------------------------------------------------","is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for","vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature by evaluating","\"NULL\", elem[1] if elem[1] != None else \"NULL\", ) for elem in result","for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] =","self, val=None, method: str = \"auto\", expr: str = \"\", by: list =","in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg","the func 'x -> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for","of moving # data around for processing, VerticaPy brings the logic to the","[float(round(item[2], 3)) for item in result], } return tablesample(values) # ---# def value_counts(self,","[ f\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\" ] expr =","--------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If set","for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT 10\".format(","the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to","import * ## # # __ __ ______ ______ __ __ __ __","used as categorical (No h will be picked or computed) h: float, optional","the search. Parameters ---------- val: list List of the different records. For example,","cast = \"::float\" if self.category() == \"float\" else \"\" if index < 0:","is date like (date, datetime ...), the parameter 'x' will represent the number","{} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(),","different transformations. Each transformation must be similar to the following: (function, type, category)","stddev ) else: final_transformation = [ ( \"({} - {}) / {}({})\".format( \"{}\",","[ (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins,","of values used to cut the vColumn. labels: list, optional Labels used to","= index_stop - index_start if limit <= 0: limit = 0 limit =","changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be able to solve","return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str =","FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\".format(","\"float\"): trans = ( \"'[' || FLOOR({} / {}) * {} || ';'","occurent element (ex: top1 for the mode) topk_percent : kth most occurent element","distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns -------","IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\", ) except:","conj, ) ) else: if verticapy.options[\"print_info\"]: print(\"Nothing was filled.\") self.transformations = [elem for","[str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be","float = 0, pie_type: str = \"auto\", ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws","vColumn using 'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate","vDataFrame expected store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\":","\"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int, float]), ] ) if func","list of at least one element to use to order the data\" )","vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"approx\", approx, [bool])]) if approx:","\"auto\", h: float = 0, nbins: int = -1, k: int = 6,","args[0] elif \"column\" in kwargs: column = kwargs[\"column\"] else: check = False if","self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count() if method","record by an input value. The vColumn will be transformed. Parameters ---------- to_replace:","more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn","query = \"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS","------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression","method to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical :","\"{}\", fun, \"{}\", \", \".join(by) ) elif method in (\"ffill\", \"pad\", \"bfill\", \"backfill\"):","int, optional Maximum number of the vColumn distinct elements to be used as","{} partitioned by {}.\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif (","after the comma. Parameters ---------- n: int Number of digits to keep after","axes object See Also -------- vDataFrame.plot : Draws the time series. \"\"\" check_types(","= self.parent.shape()[0] self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to","ASC LIMIT 1\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\"Computing the mode.\",","the vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---# def","following: date / int / float / text / binary / spatial /","be date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including","---# def clip(self, lower=None, upper=None): \"\"\" --------------------------------------------------------------------------- Clips the vColumn by transforming the","= self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique()","\"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem in order_by] for elem in","float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\"","number of matches for the regular expression in each record of the vColumn.","( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\",","the vColumn using a time series rule. \"\"\" return self.apply(func=\"DATE_PART('{}', {})\".format(field, \"{}\")) #","\"{}\", result[i - 1], result[i], result[i - 1], result[i] ) trans += \"","\"mean\": query = \"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM","vColumn distinct elements to be used as categorical (No h will be picked","\"\"\" if \"agg\" not in kwargs: query = \"SELECT {} AS {} FROM","non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER",": Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman :","See Also -------- vDataFrame.plot : Draws the time series. \"\"\" check_types( [ (\"ts\",","use to compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns","for column in order_by]) new_column = \"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER","Discretizes the vColumn using the input list. Parameters ---------- breaks: list List of","vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {}","pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression","std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return","each of the vColumn records by an input value. vDataFrame[].str_slice : Slices the","Donut chart. rose : Rose chart. It can also be a cutomized aggregation","if the vColumn is numerical. \"\"\" return self.ctype().lower() in (\"bool\", \"boolean\") # ---#","and built-in analytics and machine learning features. It supports the # entire data","the slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent See","def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements).","to use to compute the optimal h. auto : Combination of Freedman Diaconis","to order the data\" ) desc = \"\" if (method in (\"ffill\", \"pad\"))","= nb, [], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems","dropna: bool, optional If set to True, NULL values will not be considered","self.aggregate(func=[\"unique\"]).values[self.alias][0] # ---# def pie( self, method: str = \"density\", of: str =","list = [], return_trans: bool = False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input","bool = True): \"\"\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a","copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized","keeping only the input number of digits after the comma. Parameters ---------- n:","result], } return tablesample(values) # ---# def value_counts(self, k: int = 30): \"\"\"","a Step Plot. ax: Matplotlib axes object, optional The axes to plot on.","\"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] ) method = method.lower()","(\"start\", start, [bool]), ] ) start_or_end = \"START\" if (start) else \"END\" return","will not be considered during the computation. n: int, optional Integer corresponding to","method=\"fetchall\", ) return [item for sublist in query_result for item in sublist] #","vDataFrame input aggregations. \"\"\" return self.aggregate([\"max\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \"\"\"","\"{}\", fun, \"{}\", \", \".join(by) ) else: new_column = \"COALESCE({}, {}({}) OVER (PARTITION","self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines = [] columns","alias. transformations: list, optional List of the different transformations. Each transformation must be","vDataFrame of the search. Parameters ---------- val: list List of the different records.","x, [int, float]), ] ) if func not in (\"log\", \"mod\", \"pow\", \"round\"):","'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values lesser than","val: int/float/str, optional Value to use to impute the vColumn. method: dict, optional","---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError(","[str]), (\"max_cardinality\", max_cardinality, [int, float]), (\"nbins\", nbins, [int, float]), (\"h\", h, [int, float]),","False ): \"\"\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters","self.parent # ---# def distinct(self, **kwargs): \"\"\" --------------------------------------------------------------------------- Returns the distinct categories of","True if the vColumn is boolean, False otherwise. Returns ------- bool True if","greater than the threshold it will be considered as an outlier. use_threshold: bool,","must be one of the following: CENTURY / DAY / DECADE / DOQ","_ _ |_) # \\/ (/_| | |(_(_|| \\/ # / # VerticaPy","vColumn by dropping the current vColumn and creating a copy with the specified","# ---# def decode(self, *argv): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined","parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations during the","vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined","elements, please use a method in zscore|minmax\" warnings.warn(warning_message, Warning) return self mad, med","method=\"fetchall\", ) values = { \"index\": [item[0] for item in result], \"count\": [int(item[1])","optional Uses numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame","a vColumn can make the vDataFrame \"heavier\" if it is used to compute","MAD is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method ==","cosine cot : trigonometric cotangent exp : exponential function floor : value down","of the vColumn based on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type =","vDataFrame[].str_contains : Verifies if the regular expression is in each of the vColumn","chart of the vColumn based on an aggregation. \"\"\" if isinstance(pie_type, str): pie_type","to True, the lowest element of the list will be included. right: bool,","GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\".format(","h, h, \"{}\", h, h, h, floor_end ), \"varchar\", \"text\", ) else: trans","the vColumn memory usage. Returns ------- float vColumn memory usage (byte) See Also","self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset =","isin(self, val: list, *args): \"\"\" --------------------------------------------------------------------------- Looks if some specific records are in","---------- k: int, optional Number of most occurent elements to return. dropna: bool,","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---#","Plot of the input vColumns. \"\"\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)):","sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as","was renamed '{}'.\".format(old_name, new_name) ) return parent # ---# def round(self, n: int):","> 0 else \"\", self.alias ), method=\"fetchall\", ) values = { \"index\": [item[0]","nullifzero = 0 avg, stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message","Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable","FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\".format(","): n = len(result) trans = \"(CASE \" for i in range(1, n):","\"\"\" check_types( [ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\",","self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot(","# ---# def geo_plot(self, *args, **kwargs): \"\"\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters","= args[0] elif \"column\" in kwargs: column = kwargs[\"column\"] else: check = False","!= \"numerical\")) or not (is_numeric) or (method == \"categorical\") ): query = \"\"\"(SELECT","0, h: float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar","to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method != \"numerical\"))","time series. \"\"\" check_types( [ (\"ts\", ts, [str]), (\"q\", q, [tuple]), ( \"start_date\",","len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation","---------- method: str, optional The describe method. auto : Sets the method to","the transformation instead of the vDataFrame parent and do not apply it. This","it will be considered as an outlier. use_threshold: bool, optional Uses the threshold","using a Robust Z-Score - The MAD is null !\".format( self.alias ) warnings.warn(warning_message,","\"{}\", by[0], \", \".join( [\"{}, {}\".format(elem[0], elem[1]) for elem in result] ), )","# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to","def fill_outliers( self, method: str = \"winsorize\", threshold: float = 4.0, use_threshold: bool","if method not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by if","See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize","\"std\" ] elif method == \"minmax\": self.catalog[elem] = (sauv[elem] - sauv[\"min\"]) / (","in each record of the vColumn. vDataFrame[].extract : Extracts the regular expression in","vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\",","the vColumn using the input method. Parameters ---------- method: str, optional The method","--------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x: float Input","a division operation pow : number raised to the power of another number","------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the","---# def aad(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation).","the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds","the dummies ({name}).\\n\" \"It can be the result of using previously the method","= ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in","return pre_comp assert n >= 1, ParameterError(\"Parameter 'n' must be greater or equal","Discretizes the vColumn using the input method. Parameters ---------- method: str, optional The","* IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) +","\"int\", \"float\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Mean Encode]: The vColumn {} was transformed","model.fit(tmp_view_name, [self.alias], response) query = [ \"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id","for elem in result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT 1\".format(","\"avg\", \"median\", \"ffill\", \"pad\", \"bfill\", \"backfill\", ], ), (\"expr\", expr, [str]), (\"by\", by,","1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\"Getting the vColumn","in order_by] + by) by = self.parent.format_colnames(by) if method == \"auto\": method =","cmax, cmin, ) else: final_transformation = [ ( \"({} - {}) / {}({}","machine learning features. It supports the # entire data science life cycle, uses","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic :","multiple children vColumns whereas one vColumn can only have one parent. catalog: dict,","= [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins,","else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result","response column to find the most relevant interval to use for the discretization.","[elem[0] for elem in result] except: drop(tmp_view_name, method=\"view\") drop(tmp_model_name, method=\"model\") raise drop(tmp_view_name, method=\"view\")","+= list(args) check_types([(\"val\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---#","method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN","'{}' was transformed with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"),","executeSQL( query, title=\"Computing the different aggregations.\", method=\"fetchall\", ) for idx, elem in enumerate(result):","return \"({} - {}) / {}({})\".format( self.alias, avg, \"NULLIFZERO\" if (nullifzero) else \"\",","an input value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return","\"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See Also","optional Method to use to impute the missing values. auto : Mean for","parameter 'by' is empty\\nIf you want to normalize by grouping by elements, please","Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in","executeSQL( \"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias,","= result.values[self.alias] elif (method == \"cat_stats\") and (numcol != \"\"): numcol = self.parent.format_colnames(numcol)","= \"{}({})\".format(func.upper(), \"{}\") else: expr = \"{}({}, {})\".format(func.upper(), \"{}\", x) return self.apply(func=expr) #","value. vDataFrame[].str_slice : Slices the vColumn. \"\"\" check_types([(\"pat\", pat, [str])]) return self.apply( func=\"REGEXP_COUNT({},","list, optional List of the vColumns to use to sort the data when","for the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces","simply because of ambiguous columns naming.\\nBy changing one of \" \"the parameters ('prefix',","= ( \"MAX({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), \"MIN({}) OVER","vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the input","data. h: float, optional Interval width if the vColumn is numerical or of","tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the","self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() # ---# def _repr_html_(self):","self, by: str = \"\", h: float = 0, max_cardinality: int = 8,","vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using an advanced","vDataFrame input aggregations. \"\"\" return self.aggregate([\"stddev\"]).values[self.alias][0] stddev = std # ---# def store_usage(self):","of distinct elements for vColumns 1 and 2 to be used as categorical","method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The vColumn must be numerical","not (\"legend\" in kwargs): kwargs[\"legend\"] = True if not (\"figsize\" in kwargs): kwargs[\"figsize\"]","alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy","self.catalog[\"max\"] = 1 self.parent.__add_to_history__( \"[Normalize]: The vColumn '{}' was normalized with the method","= \"\"\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY","vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame","= (sauv[elem] - sauv[\"min\"]) / ( sauv[\"max\"] - sauv[\"min\"] ) except: pass if","empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already the alias {name}.\\nBy","You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #","---# def date_part(self, field: str): \"\"\" --------------------------------------------------------------------------- Extracts a specific TS field from","parameter is equal to 0, an optimised interval will be computed. nbins: int,","binary to use iv_woe.\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\"same_width\" if self.isnum() else","was transformed with the func 'x -> {}'.\".format( self.alias.replace('\"', \"\"), func.replace(\"{}\", \"x\"), )","object which that stores all user transformations. If the vDataFrame represents the entire","k: int, optional The integer k of the 'topk' method. new_category: str, optional","vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex: 50% to","AVG({}), STDDEV({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ),","self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \"[Discretize]: The vColumn {} was discretized.\".format(self.alias) ) return","range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def","self.catalog[elem] = None elif method == \"robust_zscore\": self.catalog[elem] = (sauv[elem] - sauv[\"approx_50%\"]) /","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self,","tree_id = {}, format = 'tabular'))\".format( tmp_model_name, i ) for i in range(parameters[\"n_estimators\"])","columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] = sauv[\"count\"] self.catalog[\"percent\"] = ( 100","{} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self,","the method '{}'.\".format( self.alias, method ) ) else: raise TypeError(\"The vColumn must be","------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a","discretization using the method 'same_freq'\" ) count = self.count() nb = int(float(count /","input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float): \"\"\" ---------------------------------------------------------------------------","using the average of the response partitioned by the different vColumn categories. Parameters","\".join(by) ), ) if return_trans: return \"({} - {}) / {}({} - {})\".format(","= \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\", area: bool = False, step:","each of the vColumn records. The vColumn will be transformed. Parameters ---------- pat:","else: final_transformation = [ ( \"({} - {}) / ({})\".format(\"{}\", med, mad), \"float\",","non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0","self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the descriptive statistics of {}.\".format(self.alias),","happened during the filling.\".format(e)) if total > 0: try: if \"count\" in sauv:","\"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{}, {}\".format( \"'{}'\".format(str(elem[0]).replace(\"'\", \"''\")) if elem[0]","aggregations. \"\"\" check_types([(\"x\", x, [int, float], (\"approx\", approx, [bool]))]) prefix = \"approx_\" if","else \"\" return self.aggregate(func=[prefix + \"{}%\".format(x * 100)]).values[self.alias][ 0 ] # ---# def","self.alias, \", \".join(by) ), ) else: cmax, cmin = ( \"MAX({}) OVER (PARTITION","\"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\", end_date: Union[str, datetime.datetime, datetime.date] = \"\",","of the parent vDataFrame. This parameter is used for testing purpose. Returns -------","= \"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),","generation will be slower if the vDataFrame has been transformed multiple times, so","the vColumn. You can write the following list: [\"Fouad\", \"Badr\"] Returns ------- vDataFrame","function to the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply",") p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias), method=\"fetchrow\", )","bool, optional If set to True, the record will be sliced using the","title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from","if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns =","\"acos\", \"asin\", \"atan\", \"cbrt\", \"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\",","vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding","hyperbolic tangent x: int/float, optional If the function has two arguments (example, power",") max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations","variable in relation to the dependent variable. Parameters ---------- y: str Response vColumn.","else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def","/ std robust_zscore : Normalization using the Robust Z-Score (median and mad). (x","< {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\".format( self.parent.__genSQL__(),","+ [item[0] for item in query_result] else: result = ( self.parent.describe( method=\"numerical\", columns=[self.alias],","list List of the different records. For example, to check if Badr and","(\"expr\", expr, [str]), (\"by\", by, [list]), (\"order_by\", order_by, [list]), ] ) method =","{} IS NOT NULL ORDER BY {} DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias,","One-Hot Encoding. \"\"\" check_types([(\"response\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError(","Returns ------- bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate","See Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\"","by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \"Normalize","float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, -({}), {})\".format(x, \"{}\")) else: return self.apply(func=\"{} - ({})\".format(\"{}\",","USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =","\"\"\" check_types( [ (\"ts\", ts, [str]), (\"by\", by, [str]), (\"start_date\", start_date, [str, datetime.datetime,",") return executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self,","[ (\"method\", method, [\"auto\", \"numerical\", \"categorical\", \"cat_stats\"]), (\"max_cardinality\", max_cardinality, [int, float]), (\"numcol\", numcol,","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" check_types([(\"x\", x, [int, float],","impute the vColumn. method: dict, optional Method to use to impute the missing","# data around for processing, VerticaPy brings the logic to the data. #","Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode :","Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the","will represent the number of seconds, otherwise it will represent a number. Returns","[\"winsorize\", \"null\", \"mean\"]), (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int,","when 'ts' is greater than November 1993 the 3rd. area: bool, optional If","{}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events /","stddev = self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can not normalize","not in [\"mode\", \"0ifnull\"]: max_floor = 0 all_partition = by if method in","the vColumns 1 and 2 bars. It is only valid if the vColumns","the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"', \"\")","self.transformations = ( parent, alias, [elem for elem in transformations], ) self.catalog =","get_dummies( self, prefix: str = \"\", prefix_sep: str = \"_\", drop_first: bool =","except: pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1 /","function to the vColumn. Parameters ---------- func: str, Function in pure SQL used","PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\"\"\".format( category, self.alias,","= \"Others\", RFmodel_params: dict = {}, response: str = \"\", return_enum_trans: bool =","SQL code. Note: Dropping a vColumn can make the vDataFrame \"heavier\" if it","else '\"{}{}\"'.format( prefix, str(distinct_elements[k]).replace('\"', \"_\") ) ) name = ( name.replace(\" \", \"_\")","___\\ /\\ __ \\ /\\ \\ /\\ \\/\\ \\ /\\ \"-./ \\ /\\","int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \"int\") else \"\" if (h",") ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose()","optional If set to True, draw a Step Plot. ax: Matplotlib axes object,","tuple, optional Set the x limits of the current axes. ax: Matplotlib axes","... WHEN vColumn = argv[2 * i] THEN argv[2 * i + 1]","(PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) else: cmax, cmin = (","store usage. \"\"\" pre_comp = self.parent.__get_catalog_value__(self.alias, \"store_usage\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\": return pre_comp","the absolute value function to the input vColumn. Returns ------- vDataFrame self.parent See","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0] # ---# def cut( self, breaks:","-------- vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize :","''\", \"varchar\", \"text\") if (self.isnum() and method == \"same_freq\") or ( self.isnum() and","+ 2 use \"POWER({}, 2) + 2\". copy_name: str, optional If not empty,",") tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias","True, the lowest element of the list will be included. right: bool, optional","{}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT","val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method == \"0ifnull\": new_column","NOT NULL LIMIT 20\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the",") drop(tmp_model_name, method=\"model\") if self.parent[response].category() == \"float\": model = RandomForestRegressor(tmp_model_name) else: model =","\"POWER({}, 2) + 2\". copy_name: str, optional If not empty, a copy will","numcol, cast, ) tmp_query += ( \" WHERE {} IS NULL\".format(self.alias) if (category","str, optional Method to use to compute the optimal h. auto : Combination","using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes","upper_when, \"{}\") self.apply(func=func) return self.parent # ---# def count(self): \"\"\" --------------------------------------------------------------------------- Aggregates the","title = \"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---#","- {}) / {}({} - {})\".format( \"{}\", cmin, \"NULLIFZERO\" if (nullifzero) else \"\",","statistics of {}.\".format(self.alias), method=\"fetchall\", ) result = [distinct_count, self.count()] + [item[1] for item","category will be one of the following: date / int / float /","WHERE {} IS NOT NULL LIMIT 0\".format( func.replace(\"{}\", self.alias), self.parent.__genSQL__(), self.alias, ), \"apply_test_feature\",","than the lower bound to the lower bound itself and the values higher","result] ), ) executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ),","Draws the spider plot of the input vColumn based on an aggregation. Parameters","new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj =","max_cardinality: int, optional Maximum number of vColumn distinct elements to be used as","vColumn using the mean encoding of a response. \"\"\" check_types( [ (\"RFmodel_params\", RFmodel_params,","self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx +","self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def","from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try: parent = self.parent force_columns =","\"VERTICAPY_NOT_PRECOMPUTED\": if not (dropna) and (pre_comp != None): return pre_comp assert n >=","new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name] all_new_features += [name] conj = \"s were \" if","for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent","(\"prefix\", prefix, [str]), (\"prefix_sep\", prefix_sep, [str]), (\"drop_first\", drop_first, [bool]), (\"use_numbers_as_suffix\", use_numbers_as_suffix, [bool]), ]","regular expression is in each of the vColumn records. vDataFrame[].extract : Extracts the","\"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise. Returns","str): \"\"\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ----------","pow : number raised to the power of another number round : rounds","= \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by) )","Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut chart of","unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0],","License for the specific language governing permissions and # limitations under the License.","check = True if len(args) > 0: column = args[0] elif \"column\" in","will return the transformation used instead of the parent vDataFrame. This parameter is","= True, ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx:","True, the approximate cardinality is returned. By setting this parameter to False, the","\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25)","pass total = int(total) conj = \"s were \" if total > 1","name, [str])]) name = quote_ident(name.replace('\"', \"_\")) assert name.replace('\"', \"\"), EmptyParameter( \"The parameter 'name'",".replace(\"'\", \"_\") ) expr = \"DECODE({}, '{}', 1, 0)\".format( \"{}\", str(distinct_elements[k]).replace(\"'\", \"''\") )","= self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date,","{}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} smallest elements.\".format(n,","def isdate(self): \"\"\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False","histogram bins.\", method=\"fetchall\", ) result = [elem[0] for elem in result] elif self.isnum()","containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest :","method when first preparing your data. Parameters ---------- new_name: str The new vColumn","# You may not use this file except in compliance with the License.","type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns","-1, k: int = 6, new_category: str = \"Others\", RFmodel_params: dict = {},","NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\".format( self.alias, query, ) query =","if isinstance(index, slice): assert index.step in (1, None), ValueError( \"vColumn doesn't allow slicing","= 1 / 1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] =","is null !\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \"minmax\":","will be closed on the right. Returns ------- vDataFrame self.parent See Also --------","is date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is","largest vColumn elements. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM","self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of,","were \" if len(all_new_features) > 1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]:","(median and mad). (x - median) / (1.4826 * mad) minmax : Normalization","vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval : Evaluates a","previously the method on the vColumn \" \"or simply because of ambiguous columns",") warnings.warn(warning_message, Warning) return self elif n == 1: try: result = executeSQL(","= \"\", by: list = [], order_by: list = [], ): \"\"\" ---------------------------------------------------------------------------","vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) return self.apply(func=\"ROUND({}, {})\".format(\"{}\", n)) # ---# def","1 (1 meaning global outlier). \"\"\" if isinstance(method, str): method = method.lower() check_types(","index, \"value\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method ==","IS NOT NULL \".format(self.alias) if (dropna) else \" \" result = executeSQL( \"SELECT","\"density\", of: str = \"\", max_cardinality: int = 6, nbins: int = 0,","BY count DESC\" ).format(self.alias, max_cardinality + 1) query = \"WITH vdf_table AS (SELECT","# ---# def label_encode(self): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from","try: query = \"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT","the method 'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {}","of the DB version you are using. Returns ------- tablesample An object containing","(\"threshold\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values self.parent.filter(","0.75) AS Q3, MAX({}) AS max FROM {}\".format( self.alias, self.alias, self.alias, self.alias, self.alias,","of two flower brackets {}. For example to apply the function: x ->","Slices the vColumn. \"\"\" check_types([(\"to_replace\", to_replace, [str]), (\"value\", value, [str])]) return self.apply( func=\"REGEXP_REPLACE({},","the parameter 'name', you'll be able to solve this issue.\" ) new_vColumn =","convert to use to convert the vColumn. If this parameter is equal to","record is greater than the threshold it will be considered as an outlier.","{}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER ()","Computes the vDataFrame input aggregations. \"\"\" return self.aggregate(func=[\"prod\"]).values[self.alias][0] prod = product # ---#","Returns ------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate :","{}, \"regr_sxx\": {}, \"regr_sxy\": {}, \"regr_syy\": {}, } for elem in catalog: self.catalog[elem]","assert not (self.parent.is_colname_in(new_name)), NameError( f\"A vColumn has already the alias {new_name}.\\nBy changing the","): \"\"\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks:","the vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also --------","-------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \"\"\" if isinstance(by, str): by","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS","[\"total\"] result.values[\"non_events\"] += [sum(result[\"non_events\"])] result.values[\"events\"] += [sum(result[\"events\"])] result.values[\"pt_non_events\"] += [\"\"] result.values[\"pt_events\"] += [\"\"]",": Parent of the vColumn. transformations, str : List of the different transformations.","\\ / / / # \\ / / / # \\/ / /","must be greater or equal to 1\") where = \" WHERE {} IS","= \"COALESCE({}, '{}')\".format(\"{}\", val) elif expr: new_column = \"COALESCE({}, {})\".format(\"{}\", expr) elif method","in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try:","bool, optional If set to True, the information will be stored in the","tail.name = self.alias return tail # ---# def isbool(self): \"\"\" --------------------------------------------------------------------------- Returns True","quantile(1-alpha) if 'use_threshold' is set to False else the lower and upper ZScores.",") return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int =","\"Reads {} {} largest elements.\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize(","schema = \"public\" name = gen_tmp_name(schema=schema, name=\"kde\") if isinstance(xlim, (tuple, list)): xlim_tmp =","# speed and built-in analytics and machine learning features. It supports the #","How the intervals should be closed. If set to True, the intervals will","xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in","self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\" in sauv: self.catalog[\"count\"] =","self, ts: str, by: str = \"\", start_date: Union[str, datetime.datetime, datetime.date] = \"\",","-> {}'.\".format( copy_name.replace('\"', \"\"), func.replace(\"{}\", \"x\"), ) ) else: for k in range(max_floor):","== \"robust_zscore\": if n > 0: warning_message = \"The method 'robust_zscore' is available","True, alpha: float = 0.05, ): \"\"\" --------------------------------------------------------------------------- Fills the vColumns outliers using","[\"auto\", \"donut\", \"rose\"]), ] ) donut = True if pie_type == \"donut\" else","str = \"density\", of: str = \"\", max_cardinality: int = 6, nbins: int","# / # VerticaPy is a Python library with scikit-like functionality for conducting","(elem[1] == None) else str(elem[1]) new_column = \"COALESCE({}, DECODE({}, {}, NULL))\".format( \"{}\", by[0],","distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not","float = 0, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the bar chart of","is set to False else the lower and upper ZScores. threshold: float, optional","std : standard deviation topk : kth most occurent element (ex: top1 for","to be used as categorical (No h will be picked or computed) nbins:","If set to True, the approximate quantile is returned. By setting this parameter","self.parent # ---# def dropna(self): \"\"\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn","{} IS NOT NULL) VERTICAPY_SUBTABLE {}\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, )",") else: query = \"SELECT {} FROM (SELECT {} AS {}, {} AS","vDataFrame.add_copy : Creates a copy of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name",": kurtosis jb : Jarque-Bera index mad : median absolute deviation max :","on an aggregation. \"\"\" check_types( [ (\"by\", by, [str]), (\"kernel\", kernel, [\"gaussian\", \"logistic\",","data science projects on data stored in Vertica, taking advantage Vertica’s # speed","h will be computed. ax: Matplotlib axes object, optional The axes to plot","if len(cat) == 1: lp, rp = \"(\", \")\" else: lp, rp =","NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events = 0","str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---# def","nunique(self, approx: bool = True): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality).","* FROM {}) {}\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\"Computing the","--------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float mad","round : rounds a value to a specified number of decimal places sign","= self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins if","will be transformed. Parameters ---------- field: str The field to extract. It must","[bool])]) try: parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"]","total = self.count() if (method == \"mode\") and (val == None): val =","lower bound itself and the values higher than the upper bound to the","query, title=\"Different aggregations to compute the optimal h.\", method=\"fetchrow\", ) count, vColumn_min, vColumn_025,","self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query,","NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY","of the dummies. drop_first: bool, optional Drops the first dummy to avoid the","the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements.","vColumn. \"\"\" check_types( [ (\"breaks\", breaks, [list]), (\"labels\", labels, [list]), (\"include_lowest\", include_lowest, [bool]),","---# def max(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns -------","\\ \\_____\\ \\ \\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_\\\\\"\\_\\ # \\/_/ \\/_____/",") self.parent._VERTICAPY_VARIABLES_[\"columns\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\"exclude_columns\"] += [self.alias] if add_history: self.parent.__add_to_history__( \"[Drop]: vColumn","(\"cat_priority\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot","to True, NULL values will not be considered during the computation. n: int,","str = \"density\", of: str = \"\", max_cardinality: Union[int, tuple] = (6, 6),","float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias,","for k in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += [(func, ctype,","ParameterError( \"Length of parameter 'breaks' must be greater or equal to 2.\" )","func = \"(CASE {}{}ELSE {} END)\".format(lower_when, upper_when, \"{}\") self.apply(func=func) return self.parent # ---#","if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\"method\", method, [str]), (\"of\", of,","Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See","user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to impute the","-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0] # ---#","categories to normalize.\", method=\"fetchall\", ) for i in range(len(result)): if result[i][2] == None:","the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query = \"SELECT * FROM {}","str Name of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval","utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \"\"\"","NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER","The vColumn '{}' was normalized with the method '{}'.\".format( self.alias, method ) )","[lp + tmp_query + rp] query = \"WITH vdf_table AS (SELECT * FROM","Number of elements. density : Percentage of the distribution. mean : Average of","---------- k: int, optional Number of most occurent elements to return. Returns -------","Applies a function to the vColumn. Parameters ---------- func: str, Function in pure","vDataFrame[].isnum : Returns True if the vColumn is numerical. \"\"\" return self.category() ==","* FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT","name of the merging category when using the 'topk' method. RFmodel_params: dict, optional","min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING","Z-Score (median and mad). (x - median) / (1.4826 * mad) minmax :","RFmodel_params: dict = {}, response: str = \"\", return_enum_trans: bool = False, ):","\"ceil\", \"cos\", \"cosh\", \"cot\", \"exp\", \"floor\", \"ln\", \"log\", \"log10\", \"mod\", \"pow\", \"round\", \"sign\",","\"\"\" check_types( [ (\"alpha\", alpha, [int, float]), (\"use_threshold\", use_threshold, [bool]), (\"threshold\", threshold, [int,","= self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0: warning_message = \"Can not","Maximum number of points to use to evaluate the approximate density function. Increasing","if return_trans: return \"({} - {}) / ({})\".format(self.alias, med, mad) else: final_transformation =","= [ column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM","_ # \\ / _ __|_. _ _ |_) # \\/ (/_| |","using multiple statistical aggregations: min, max, median, unique... depending on the input method.","= \"\", area: bool = False, step: bool = False, ax=None, **style_kwds, ):","self.ctype(), self.category())] self.transformations += [ (\"AVG({}) OVER (PARTITION BY {})\".format(response, \"{}\"), \"int\", \"float\")","n > 0: warning_message = \"The method 'robust_zscore' is available only if the","(\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ] ) start_or_end","for the discretization (must be > 1) k: int, optional The integer k","by: list, optional vColumns used in the partition. return_trans: bool, optimal If set","return self.category() == \"date\" # ---# def isin(self, val: list, *args): \"\"\" ---------------------------------------------------------------------------","1) else \"LIMIT {}\".format(k) dropna = \" WHERE {} IS NOT NULL\".format(self.alias) if","but will also increase the time of the learning and scoring phases. xlim:","the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes","\"MIN({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans: return","in range(max_floor): self.transformations += [(\"{}\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {}",") executeSQL( \"SELECT {} FROM {} LIMIT 1\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, )","and include_lowest: op1, close_l = \"<=\", \"[\" elif idx == 0: op1, close_l","= \"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_","vDataFrame.drop: Drops the input vColumns from the vDataFrame. \"\"\" check_types([(\"add_history\", add_history, [bool])]) try:",": arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent x:","self.catalog[\"percent\"] = 100 self.parent.__add_to_history__( \"[Label Encoding]: Label Encoding was applied to the vColumn","else: raise TypeError(\"The vColumn must be numerical for Normalization\") return self.parent # ---#","---------- approx: bool, optional If set to True, the approximate cardinality is returned.","-------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies a","One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep:","silverman : Silverman kernel. nbins: int, optional Maximum number of points to use","of the search. See Also -------- vDataFrame.isin : Looks if some specific records","[0, n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent","max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [","self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \"UNION ALL (SELECT","and a limit). Parameters ---------- limit: int, optional Number of elements to display.","), title=\"Computing the mode.\", method=\"fetchall\", ) top = None if not (result) else","cut( self, breaks: list, labels: list = [], include_lowest: bool = True, right:","'topk'\" ) distinct = self.topk(k).values[\"index\"] trans = ( \"(CASE WHEN {} IN ({})","set to True, draw an Area Plot. step: bool, optional If set to","_verticapy_cnt_ DESC {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result","max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\"{}\",","percents. Parameters ---------- k: int, optional Number of most occurent elements to return.","the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog,","as e: raise ConversionError( \"{}\\nThe vColumn {} can not be converted to {}\".format(","= to_tablesample( \"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\".format( bin_spatial_to_str(self.category(),","aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self, method:","must not be empty\" ) assert not (self.parent.is_colname_in(name)), NameError( f\"A vColumn has already","transformation operations, and offers beautiful graphical options. # # VerticaPy aims to do","method. Parameters ---------- method: str, optional The describe method. auto : Sets the","mode.\", method=\"fetchall\", ) top = None if not (result) else result[0][0] if not","to the vColumn. Parameters ---------- func: str, Function in pure SQL used to","0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor","elif self.isnum() and method == \"same_freq\": assert nbins >= 2, ParameterError( \"Parameter 'nbins'","will be computed if the parameter is empty or invalid. max_cardinality: int, optional","{} > {} THEN {} ELSE {} END)\".format( \"{}\", p_alpha, mean_alpha, \"{}\", p_1_alpha,","\"\" if (k < 1) else \"LIMIT {}\".format(k) dropna = \" WHERE {}","\"\"\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating a","DESC LIMIT {}\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {}","else \" \" result = executeSQL( \"SELECT {} FROM (SELECT {}, COUNT(*) AS","the vColumn. The aggregations used are the median and two input quantiles. Parameters","-------- vDataFrame[].slice : Slices the vColumn using a time series rule. \"\"\" return","---------- n: int, optional Offset. Returns ------- tablesample An object containing the result.","result = executeSQL( query=query, title=\"Computing the equal frequency histogram bins.\", method=\"fetchall\", ) result","median absolute deviation max : maximum mean : average median : median min","cmin, ), \"float\", \"float\", ) ] if method != \"robust_zscore\": max_floor = 0","values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values)","the threshold, it will be considered as an outlier. use_threshold: bool, optional Uses",": Returns the vColumn most occurent elements. \"\"\" if \"agg\" not in kwargs:","check_types([(\"x\", x, [int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return","AS ord, {}::int AS {} FROM {}\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(),","\"START\" if (start) else \"END\" return self.apply( func=\"TIME_SLICE({}, {}, '{}', '{}')\".format( \"{}\", length,","\"[Label Encoding]: Label Encoding was applied to the vColumn {} using the following","# ---# def std(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation).","method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by:","**style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ----------","= self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax,","---# def apply(self, func: str, copy_name: str = \"\"): \"\"\" --------------------------------------------------------------------------- Applies a","functions. Parameters ---------- func: list List of the different aggregation. aad : average","op1, close_l = \"<=\", \"[\" elif idx == 0: op1, close_l = \"<\",","memory usage. \"\"\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations)","= \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min,","must be greater or equals to 2 in case of discretization using the","self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\"Testing the Type casting.\") self.transformations +=","the MIN and the MAX. MAX = MIN !\".format( self.alias ) warnings.warn(warning_message, Warning)","Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of","information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.","the n smallest elements in the vColumn. \"\"\" check_types([(\"n\", n, [int, float])]) query","at risk dtype : vColumn type iqr : interquartile range kurtosis : kurtosis","self.count()] + [item[1] for item in query_result] index = [\"unique\", \"count\"] + [item[0]","the vColumn. \"\"\" check_types( [ ( \"func\", func, [ \"abs\", \"acos\", \"asin\", \"atan\",","the vColumn outliers using the input method. \"\"\" check_types([(\"lower\", lower, [float, int]), (\"upper\",","] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1,","column for column in self.parent._VERTICAPY_VARIABLES_[\"columns\"] ] force_columns.remove(self.alias) executeSQL( \"SELECT * FROM {} LIMIT","func: list): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ----------","of bins will be computed. h: float, optional Interval width of the bar.","int, optional Number of nbins. If empty, an optimized number of nbins will",") except: pass if method == \"robust_zscore\": self.catalog[\"median\"] = 0 self.catalog[\"mad\"] = 1","Also -------- vDataFrame.astype : Converts the vColumns to the input type. \"\"\" check_types([(\"dtype\",","computation. n: int, optional Integer corresponding to the offset. For example, if n","encoder was applied to the vColumn {}\\n{} feature{}created: {}\".format( self.alias, len(all_new_features), conj, \",","elem[0] != None else \"NULL\", elem[1] if elem[1] != None else \"NULL\", )","if the regular expression is in each of the vColumn records. vDataFrame[].extract :","isinstance(index, slice): assert index.step in (1, None), ValueError( \"vColumn doesn't allow slicing having","(int(sauv[\"count\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total) conj =","self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\"Computing the quantiles of {}.\".format(self.alias),","datetime.datetime, datetime.date, int, float], ), (\"plot_median\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts =","def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\"max_rows\"]).__repr__() #","Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a","[ (\"length\", length, [int, float]), (\"unit\", unit, [str]), (\"start\", start, [bool]), ] )","), method=\"fetchall\", ) ] if mean_alpha == None: mean_alpha = \"NULL\" if mean_1_alpha","the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame","self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self):","(count) ** (1.0 / 3.0), 1e-99) if method.lower() == \"sturges\": best_h = sturges","Density Plot. Parameters ---------- by: str, optional vColumn to use to partition the","The describe method. auto : Sets the method to 'numerical' if the vColumn","vColumn using the input method. Parameters ---------- method: str, optional The method to","(self.max() - self.min()) * 1.01 / nbins if h > 0.01: h =","use_threshold: result = self.aggregate(func=[\"std\", \"avg\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\"std\"][0] +","\"::int\" if (self.parent[numcol].isbool()) else \"\" query, cat = [], self.distinct() if len(cat) ==","Badr and Fouad are in the vColumn. You can write the following list:","NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias,","quantile is returned. By setting this parameter to False, the function's performance can","pat: str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count :","input method. Parameters ---------- method: str, optional Method to use to normalize. zscore","( parent, alias, [elem for elem in transformations], ) self.catalog = { \"cov\":","use to compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn","by if method in [\"ffill\", \"pad\", \"bfill\", \"backfill\"]: all_partition += [elem for elem","mad *= 1.4826 if mad != 0: if return_trans: return \"({} - {})","end_date: Union[str, datetime.datetime, datetime.date] = \"\", plot_median: bool = False, ax=None, **style_kwds, ):","[int, float])]) return self.apply(func=\"SUBSTR({}, {}, {})\".format(\"{}\", start, step)) # ---# def sub(self, x:","str = \"\", max_cardinality: int = 6, h: float = 0, pie_type: str","usage. Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage :","one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this","type numeric|date\" ) if self.isnum(): result = ( self.parent.describe( method=\"numerical\", columns=[self.alias], unique=False )","200, xlim: tuple = None, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the vColumn","that represents the quantile. For example: 0.25 represents Q1. approx: bool, optional If","new categories. If empty, names will be generated. include_lowest: bool, optional If set","> 0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat: str): \"\"\" ---------------------------------------------------------------------------","+ 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count)","), method=\"fetchall\", ) cmin = \"DECODE({}, {}, NULL)\".format( by[0], \", \".join( [ \"{},","Normalization using the Z-Score (avg and std). (x - avg) / std robust_zscore","1.4826 elif method == \"zscore\": self.catalog[\"mean\"] = 0 self.catalog[\"std\"] = 1 elif method","of the kernel. kernel: str, optional The method used for the plot. gaussian","using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate","Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set","the input method. Parameters ---------- method: str, optional Method to use to normalize.","\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),","input aggregations. \"\"\" return self.aggregate([\"avg\"]).values[self.alias][0] mean = avg # ---# def bar( self,","version you are using. Returns ------- tablesample An object containing the result. For","True, the information will be stored in the vDataFrame history. Returns ------- vDataFrame","Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","0 cmin, cmax = self.aggregate([\"min\", \"max\"]).values[self.alias] if cmax - cmin == 0: warning_message","), \"STDDEV({}) OVER (PARTITION BY {})\".format( self.alias, \", \".join(by) ), ) if return_trans:","for elem in transformations], ) self.catalog = { \"cov\": {}, \"pearson\": {}, \"spearman\":","ParameterError( \"At least 'lower' or 'upper' must have a numerical value\" ) lower_when","fun == \"MEDIAN\": val = self.median() new_column = \"COALESCE({}, {})\".format(\"{}\", val) elif (len(by)","to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\") # ---# def add(self, x: float):","---# def apply_fun(self, func: str, x: float = 2): \"\"\" --------------------------------------------------------------------------- Applies a","the Random Forest on a response column to find the most relevant interval","bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query,","executeSQL( query=query, title=\"Getting the vColumn element.\", method=\"fetchfirstelem\", ) else: return getattr(self, index) #","if return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for elem","and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1","if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \"DECODE({},","if index < 0: index += self.parent.shape()[0] query = \"SELECT {}{} FROM {}{}","else prefix.replace('\"', \"_\") + prefix_sep.replace('\"', \"_\") ) n = 1 if drop_first else","not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax = xlim","{ \"index\": [item[0] for item in result], \"count\": [int(item[1]) for item in result],","y, y, query, ) query = \"SELECT {}, ord, non_events, events, non_events /","typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import * from","str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts","the method 'smart'.\" ) assert response, ParameterError( \"Parameter 'response' can not be empty","result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \"(SELECT","\"method\", method, [\"auto\", \"smart\", \"same_width\", \"same_freq\", \"topk\"], ), (\"return_enum_trans\", return_enum_trans, [bool]), ] )",": base 10 logarithm mod : remainder of a division operation pow :","len(all_new_features), conj, \", \".join(all_new_features) ) + \".\" ) return self.parent one_hot_encode = get_dummies","be one of the following: CENTURY / DAY / DECADE / DOQ /","ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \"[Apply]: The vColumn '{}' was transformed with the","self.alias, query, ) query = \"SELECT {} AS index, non_events, events, pt_non_events, pt_events,","ambiguous columns naming.\\nBy changing one of \" \"the parameters ('prefix', 'prefix_sep'), you'll be","final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the","aggregation. Parameters ---------- by: str, optional vColumn to use to partition the data.","[sum(result[\"iv\"])] return result # ---# def kurtosis(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using","float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str = \"auto\", h:","[str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area, [bool]), (\"step\", step,","{column} {op2} '{second_elem}' THEN '{label}'\" ] expr = \"CASE WHEN \" + \"","ValueError( \"vColumn doesn't allow slicing having steps different than 1.\" ) index_stop =","= self.aggregate([\"avg\", \"std\"]).values[self.alias] if stddev == 0: warning_message = \"Can not normalize {}",") ) return self.parent except Exception as e: raise QueryError( \"{}\\nError when applying","NOT NULL GROUP BY {} ORDER BY {}\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias,","# ---# def spider( self, by: str = \"\", method: str = \"density\",","bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns","BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\".format( self.alias,","# |______ / / / # |____/ / / # _____________ / /","Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based on an","ax.set_title(\"KernelDensity\") ax.legend( custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax","AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1,","custom_lines, columns, title=by, loc=\"center left\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel =","that relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias: str","if return_trans: return \"({} - {}) / {}({} - {})\".format( self.alias, cmin, \"NULLIFZERO\"","The vColumn will be transformed. Parameters ---------- start: int Start of the slicing.","\"median\"): fun = \"MEDIAN\" if (method == \"median\") else \"AVG\" if by ==","check_types( [ (\"by\", by, [str]), (\"method\", method, [str]), (\"of\", of, [str]), (\"max_cardinality\", max_cardinality,","\"spearman\": {}, \"spearmand\": {}, \"kendall\": {}, \"cramer\": {}, \"biserial\": {}, \"regr_avgx\": {}, \"regr_avgy\":","(SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {}","------- str vColumn DB type. \"\"\" return self.transformations[-1][1].lower() dtype = ctype # ---#","0\".format(\"{}\", pat.replace(\"'\", \"''\")) ) # ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes","the parameter is empty or invalid. max_cardinality: int, optional Maximum number of vColumn","element percent : percent of non-missing elements q% : q quantile (ex: 50%","return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \"\", prefix_sep:","computed) nbins: int, optional Number of bins. If empty, an optimized number of","# ---# def str_count(self, pat: str): \"\"\" --------------------------------------------------------------------------- Computes the number of matches","self.transformations] total = self.count() if method not in [\"mode\", \"0ifnull\"]: max_floor = 0","the func 'x -> {}' to '{}'\".format( e, func.replace(\"{}\", \"x\"), self.alias.replace('\"', \"\") )","self.alias, ), \"apply_test_feature\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for","response column must be numerical to use a mean encoding\" ) max_floor =","have multiple children vColumns whereas one vColumn can only have one parent. catalog:","(most occurent element). 0ifnull : 0 when the vColumn is null, 1 otherwise.","__ __ ______ ______ __ __ __ __ __ __ __ # /\\","ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]","Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled","Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a","[0, 1], TypeError( \"vColumn {} must be binary to use iv_woe.\".format(y) ) self.parent[y].distinct()","0.25 represents Q1. approx: bool, optional If set to True, the approximate quantile","== \"int\") else \"\" if (h > 1) or (self.category() == \"float\"): trans","self.parent.__genSQL__(), self.alias, self.alias, n ) title = \"Reads {} {} largest elements.\".format(self.alias, n)","= fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\"index\": [\"numh\"], self.alias: [best_h]}) if self.category()","[list]), (\"order_by\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in","the function's performance can drastically decrease. Returns ------- float quantile (or approximate quantile).","0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\"', \"\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\"columns\"] += [name]","\"float\" else \"\" if index < 0: index += self.parent.shape()[0] query = \"SELECT",") query_result = executeSQL( query=query, title=\"Computing the distinct categories of {}.\".format(self.alias), method=\"fetchall\", )","or computed) nbins: int, optional Number of nbins. If empty, an optimized number","Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" return","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"sum\"]).values[self.alias][0]","--------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var See Also","[int, float])]) if self.isdate(): return self.apply(func=\"TIMESTAMPADD(SECOND, {}, {})\".format(x, \"{}\")) else: return self.apply(func=\"{} +","setting this parameter to False, the function's performance can drastically decrease. Returns -------","---# def sem(self): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of","head(self, limit: int = 5): \"\"\" --------------------------------------------------------------------------- Returns the head of the vColumn.","of the vColumn. \"\"\" check_types([(\"new_name\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\"',","method.lower() if method == \"auto\": pre_comp = self.parent.__get_catalog_value__(self.alias, \"numh\") if pre_comp != \"VERTICAPY_NOT_PRECOMPUTED\":","vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the input","Number of most occurent elements to return. dropna: bool, optional If set to","\"round\", \"sign\", \"sin\", \"sinh\", \"sqrt\", \"tan\", \"tanh\", ], ), (\"x\", x, [int, float]),","-------- vDataFrame[].apply : Applies a function to the input vColumn. \"\"\" return self.apply(func=\"ABS({})\")","{}\".format(str(distinct_elements[k]).replace(\"'\", \"''\"), k) ] text_info += \"\\t{} => {}\".format(distinct_elements[k], k) expr = \",","vColumns. Parameters ---------- add_history: bool, optional If set to True, the information will","Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input","other vColumns. Parameters ---------- add_history: bool, optional If set to True, the information","dummies. drop_first: bool, optional Drops the first dummy to avoid the creation of","\"''\") ) transformations = self.transformations + [(expr, \"bool\", \"int\")] new_vColumn = vColumn( name,","__ ______ ______ __ __ __ __ __ __ __ # /\\ \\","table ) result = executeSQL( query, title=\"Different aggregations to compute the optimal h.\",","[str]), (\"start_date\", start_date, [str, datetime.datetime, datetime.date]), (\"end_date\", end_date, [str, datetime.datetime, datetime.date]), (\"area\", area,","aad : average absolute deviation approx_unique : approximative cardinality count : number of","or equals to 2 in case of discretization using the method 'same_freq'\" )","int, float], ), ( \"end_date\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\"plot_median\",","See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \"\"\" return self.aggregate([\"count\"]).values[self.alias][0]","0 for k in range(len(distinct_elements) - n): name = ( '\"{}{}\"'.format(prefix, k) if","bool = False, ax=None, **style_kwds, ): \"\"\" --------------------------------------------------------------------------- Draws the range plot of","1 else \" was \" self.parent.__add_to_history__( \"[Get Dummies]: One hot encoder was applied","bool = False, ): \"\"\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding","pat: str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :","max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if","with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of","= self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \"The response column must be numerical to use","6, numcol: str = \"\" ): \"\"\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple","\"text\") if (self.isnum() and method == \"same_freq\") or ( self.isnum() and method ==","optional vColumns used in the partition. order_by: list, optional List of the vColumns","self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \"::float\"","ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\"Computing the Store Usage of the","[name] self.parent.__add_to_history__( \"[Add Copy]: A copy of the vColumn {} named {} was","at least one element to use to order the data\" ) desc =","(\"mean\", \"median\") or isinstance(val, float): category, ctype = \"float\", \"float\" elif method ==","log10 : base 10 logarithm mod : remainder of a division operation pow","{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \"count\"","the vDataFrame input aggregations. \"\"\" return self.aggregate([\"skewness\"]).values[self.alias][0] skew = skewness # ---# def","new_column = \"COALESCE({}, {}({}) OVER (PARTITION BY {}))\".format( \"{}\", fun, \"{}\", \", \".join(by)"],"string":"[\n \"sort the data when using TS methods. Returns ------- vDataFrame self.parent See Also\",\n \"be able to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]:\",\n \"the nth most occurent element. Parameters ---------- dropna: bool, optional If set to\",\n \"product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See\",\n \"\\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str,\",\n \"the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None):\",\n \") result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", )\",\n \"in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\",\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means\",\n \"the vColumn using the input functions. Parameters ---------- func: list List of the\",\n \"1993 the 3rd. plot_median: bool, optional If set to True, the Median will\",\n \"-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) #\",\n \"{}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias,\",\n \"ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else:\",\n \"minmax : Normalization using the MinMax (min and max). (x - min) /\",\n \"{})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name:\",\n \"== \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias]\",\n \"MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({})\",\n \"---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category\",\n \"cot : trigonometric cotangent exp : exponential function floor : value down to\",\n \"optimal If set to True, the method will return the transformation used instead\",\n \"query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result =\",\n \"or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also\",\n \"for vColumns 1 and 2 to be used as categorical (No h will\",\n \"try: parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ]\",\n \"EmptyParameter( \\\"The parameter 'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError(\",\n \"(\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k)\",\n \"Freedman Diaconis [2 * IQR / n ** (1 / 3)] sturges :\",\n \"close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1,\",\n \"= ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min()\",\n \"aggregations to gain in performance. The catalog will be updated when the parent\",\n \") method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by =\",\n \"https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check\",\n \"= \\\"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM {}\\\".format(\",\n \"str, optional If not empty, a copy will be created using the input\",\n \"self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit: str =\",\n \"bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [\",\n \"datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False,\",\n \"BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or\",\n \"the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean\",\n \"# \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If the vDataFrame\",\n \"used as categorical. The less frequent elements will be gathered together to create\",\n \"\\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT\",\n \") cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"datetime, timestamp...) or numerical. by: str, optional vColumn to use to partition the\",\n \"labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str):\",\n \"Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also --------\",\n \"list, optional Labels used to name the new categories. If empty, names will\",\n \"kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs):\",\n \"OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]:\",\n \"vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float = 4.0,\",\n \"= \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, nbins: int =\",\n \"than the upper bound to the upper bound itself. Parameters ---------- lower: float,\",\n \"2, ParameterError( \\\"Length of parameter 'breaks' must be greater or equal to 2.\\\"\",\n \"({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"the Random Forest model parameters used to compute the best splits when 'method'\",\n \"(\\\"upper\\\", upper, [float, int])]) assert (lower != None) or (upper != None), ParameterError(\",\n \"+= [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__(\",\n \"\\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int,\",\n \"aims to do all of the above. The idea is simple: instead of\",\n \"after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\",\n \"------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the\",\n \"import * from verticapy.errors import * ## # # __ __ ______ ______\",\n \"Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) +\",\n \"the MinMax (min and max). (x - min) / (max - min) by:\",\n \"self.parent See Also -------- vDataFrame[].apply : Applies a function to the input vColumn.\",\n \"\\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category\",\n \"vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes\",\n \"value of the record is greater than the threshold, it will be considered\",\n \"WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format(\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{}\",\n \"(SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC\",\n \"threshold: float, optional Uses the Gaussian distribution to define the outliers. After normalizing\",\n \"elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total >\",\n \"empty, an optimized number of bins will be computed. h: float, optional Interval\",\n \": Draws the histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"result = [elem[0] for elem in result] elif self.isnum() and method in (\\\"same_width\\\",\",\n \"ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, )\",\n \"x: float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0]\",\n \"not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias:\",\n \"AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS\",\n \"vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\",\",\n \"float, optional Uses the Gaussian distribution to identify outliers. After normalizing the data\",\n \"result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])]\",\n \"if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---# def\",\n \"numerical and Mode for the categorical vColumns. bfill : Back Propagation of the\",\n \"the transformation used instead of the parent vDataFrame. This parameter is used for\",\n \"title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name =\",\n \"__getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't\",\n \"bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self,\",\n \"limitations under the License. # # |_ |~) _ _| _ /~\\\\ _\",\n \"!= None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\",\",\n \"as categorical. numcol: str, optional Numerical vColumn to use when the parameter method\",\n \"zscore : Normalization using the Z-Score (avg and std). (x - avg) /\",\n \"p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0],\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value\",\n \"in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method\",\n \"1, ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\") where = \\\"\",\n \"query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value\",\n \"'{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query\",\n \"computation. max_cardinality: int, optional Cardinality threshold to use to determine if the vColumn\",\n \"'{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i in\",\n \"{})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] =\",\n \"the current vColumn and creating a copy with the specified name. \\\\u26A0 Warning\",\n \"cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor\",\n \"import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name =\",\n \"\\\"License\\\"); # You may not use this file except in compliance with the\",\n \"else \\\"\\\" ) upper_when = ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\",\",\n \"TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans =\",\n \"Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check = True\",\n \"of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]),\",\n \"# ---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date:\",\n \": SQL code generation will be slower if the vDataFrame has been transformed\",\n \"/ / / # \\\\ / / / # \\\\_______/ / / #\",\n \"Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram of the\",\n \"numerical : Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality\",\n \"'use_threshold' is set to False else the lower and upper ZScores. threshold: float,\",\n \"trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the function has\",\n \"nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)])\",\n \"h = round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end\",\n \"(\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix +\",\n \"spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def\",\n \"assert k >= 2, ParameterError( \\\"Parameter 'k' must be greater or equals to\",\n \"/ / # \\\\ / / / # \\\\_______/ / / # ______\",\n \"kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of points to\",\n \"except Exception as e: raise QueryError( \\\"{}\\\\nError when applying the func 'x ->\",\n \"Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the\",\n \"def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float\",\n \"\\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\",\",\n \"med, mad) else: final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med,\",\n \"sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) /\",\n \"RF Regressor will be trained if the response is numerical (except ints and\",\n \"+ total) / self.parent.shape()[0] ) except: pass total = int(total) conj = \\\"s\",\n \"name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") )\",\n \"= \\\"Can not normalize {} using a Robust Z-Score - The MAD is\",\n \"order_by = [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\",\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\"\",\n \"\\\" UNION ALL \\\".join(query) ) title = \\\"Describes the statics of {} partitioned\",\n \"= [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\",\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"new vDataFrame of the search. Parameters ---------- val: list List of the different\",\n \") return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where\",\n \"self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations to compute the\",\n \"Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" if self.category()\",\n \"be used as categorical (No h will be picked or computed) h: float,\",\n \"values will not be considered during the computation. Returns ------- tablesample An object\",\n \"is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method\",\n \"len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif\",\n \"Returns True if the vColumn category is date, False otherwise. Returns ------- bool\",\n \"else \\\"NULL\\\", ) for elem in result if elem[2] != None ] ),\",\n \"See Also -------- vDataFrame.isin : Looks if some specific records are in the\",\n \"for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"]\",\n \"\\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])])\",\n \"check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n == 1: pre_comp =\",\n \"f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\"\",\n \"method: str, optional The describe method. auto : Sets the method to 'numerical'\",\n \"\\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2]\",\n \"means simply not selecting it in the final generated SQL code. Note: Dropping\",\n \"elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <=\",\n \"---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first:\",\n \"type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog:\",\n \"# ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user\",\n \"---# def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of\",\n \"{} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"/ # / / # / / # \\\\ / # \\\\ /\",\n \"the regular expression is in each of the vColumn records. vDataFrame[].extract : Extracts\",\n \"------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"-------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns\",\n \"# # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores\",\n \") .transpose() .values[self.alias] ) result = [distinct_count] + result index = [ \\\"unique\\\",\",\n \"-------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \\\"\\\"\\\" check_types(\",\n \"Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount\",\n \") return [item for sublist in query_result for item in sublist] # ---#\",\n \"return_trans: bool, optimal If set to True, the method will return the transformation\",\n \"vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) +\",\n \"Applies functions to the input vColumns. vDataFrame.applymap : Applies a function to all\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence\",\n \"AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1],\",\n \"be picked or computed) h: float, optional Interval width of the bar. If\",\n \"str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, h: float\",\n \"an optimized h will be computed. pie_type: str, optional The type of pie\",\n \"value at risk dtype : vColumn type iqr : interquartile range kurtosis :\",\n \"drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha: float =\",\n \"all_partition += [elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations)\",\n \"value up to the next whole number cos : trigonometric cosine cosh :\",\n \"offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited\",\n \"elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column =\",\n \"nbins: int, optional Maximum number of points to use to evaluate the approximate\",\n \"int Start of the slicing. step: int Size of the slicing. Returns -------\",\n \"-> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as\",\n \"topk = \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\"\",\n \"== \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {}) * {} ||\",\n \"Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias)\",\n \"The vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns -------\",\n \"if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model =\",\n \"upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0,\",\n \"isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise.\",\n \"max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts:\",\n \"is greater than the threshold, it will be considered as an outlier. use_threshold:\",\n \"parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS\",\n \"The category will be one of the following: date / int / float\",\n \"parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias)\",\n \"== \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ): n = len(result)\",\n \"\\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias)\",\n \"in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def\",\n \"and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]),\",\n \"index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing having steps different than\",\n \"vDataFrame. Dropping a vColumn means simply not selecting it in the final generated\",\n \"{}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif\",\n \"---------- x: float If the vColumn type is date like (date, datetime ...),\",\n \"else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column]\",\n \"nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER\",\n \"str, optional The type of pie chart. auto : Regular pie chart. donut\",\n \") assert response, ParameterError( \\\"Parameter 'response' can not be empty in case of\",\n \"isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop -\",\n \"maximum depth of 10. response: str, optional Response vColumn when method is set\",\n \"[bool])]) topk = \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna =\",\n \"using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def\",\n \"def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information\",\n \"the time of the learning and scoring phases. xlim: tuple, optional Set the\",\n \"NameError( f\\\"A vColumn has already the alias of one of the dummies ({name}).\\\\n\\\"\",\n \"self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0:\",\n \"the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert\",\n \") lower_when = ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower)\",\n \"= \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {}\",\n \"nth most occurent element. Parameters ---------- dropna: bool, optional If set to True,\",\n \"outliers using the input method. Parameters ---------- method: str, optional Method to use\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"Diaconis [2 * IQR / n ** (1 / 3)] sturges : Sturges\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut chart\",\n \"one_hot_encode = get_dummies # ---# def head(self, limit: int = 5): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"if elem[2] != None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {}\",\n \"the partition. return_trans: bool, optimal If set to True, the method will return\",\n \"please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med =\",\n \"kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See\",\n \"See Also -------- vDataFrame[].slice : Slices the vColumn using a time series rule.\",\n \"\\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def spider( self, by: str\",\n \"val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun ==\",\n \"this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name = (\",\n \"(14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str =\",\n \"the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent\",\n \"feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"vColumn. Parameters ---------- x: float If the vColumn type is date like (date,\",\n \"vColumns are numerical. Optimized h will be computed if the parameter is empty\",\n \"pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\"\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev\",\n \": skewness sum : sum std : standard deviation topk : kth most\",\n \"outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter. alpha:\",\n \"one column of that relation. vColumns simplify several processes with its abstractions. Parameters\",\n \"width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower()\",\n \"to a specified number of decimal places sign : arithmetic sign sin :\",\n \"= labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND\",\n \"tablesample(values) # ---# def discretize( self, method: str = \\\"auto\\\", h: float =\",\n \"conditional value at risk dtype : vColumn type iqr : interquartile range kurtosis\",\n \"the # entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize\",\n \"# ---# def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k\",\n \"= self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality, h,\",\n \"else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters =\",\n \"optional Number representing the outliers threshold. Values lesser than quantile(alpha) or greater than\",\n \"= [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx],\",\n \"'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent and\",\n \"Step Plot. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format(\",\n \"in the partition. return_trans: bool, optimal If set to True, the method will\",\n \"Minimum of the vColumn 'of'. max : Maximum of the vColumn 'of'. sum\",\n \"do all of the above. The idea is simple: instead of moving #\",\n \"empty in case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response =\",\n \"the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] = (\",\n \"list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of\",\n \"stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION\",\n \"approximate cardinality is returned. By setting this parameter to False, the function's performance\",\n \"the vColumn using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate\",\n \"elements will be gathered together to create a new category : 'Others'. cat_priority:\",\n \"model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100})\",\n \"(h) or h <= 0: if nbins <= 0: h = self.numh() else:\",\n \"= False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters\",\n \"= model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name\",\n \"self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit = 0\",\n \"use to impute the vColumn. method: dict, optional Method to use to impute\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule. Parameters\",\n \"'count' (Number of non-Missing elements). Returns ------- int number of non-Missing elements. See\",\n \"apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function\",\n \"else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx,\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx)\",\n \"be empty.\\\" ) conditions, column = [], self.alias for idx in range(len(breaks) -\",\n \"by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\",\",\n \"\\\"max_depth\\\": 10} to train a Random Forest with 20 trees and a maximum\",\n \"xlim: xmin = self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines\",\n \"return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None:\",\n \"one element to use to order the data\\\" ) desc = \\\"\\\" if\",\n \"with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the\",\n \"---------- y: str Response vColumn. nbins: int, optional Maximum number of nbins used\",\n \"\\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by)\",\n \"str, optional Method to use to normalize. zscore : Normalization using the Z-Score\",\n \"= 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__(\",\n \"= self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr\",\n \"name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({},\",\n \"be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See\",\n \"by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL(\",\n \"/ self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\"\",\n \"OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha,\",\n \"fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() ==\",\n \"(1, None), ValueError( \\\"vColumn doesn't allow slicing having steps different than 1.\\\" )\",\n \"pie chart of the vColumn based on an aggregation. Parameters ---------- method: str,\",\n \"query = \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"\\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans\",\n \"\\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif\",\n \"a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]),\",\n \"function: x -> x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str,\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn\",\n \"date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str,\",\n \") trans += \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if\",\n \"== \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP\",\n \"Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True if the\",\n \"self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work\",\n \"vColumn {} was transformed using a mean encoding with {} as Response Column.\\\".format(\",\n \"is simple: instead of moving # data around for processing, VerticaPy brings the\",\n \"picked or computed) nbins: int, optional Number of nbins. If empty, an optimized\",\n \"False, the function's performance can drastically decrease. Returns ------- float quantile (or approximate\",\n \"= \\\"gaussian\\\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ):\",\n \"\\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\",\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float\",\n \"/ / # \\\\ / # \\\\ / # \\\\/ # _ #\",\n \"FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE\",\n \"& IV of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"]\",\n \"if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem\",\n \"\\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n == 1: pre_comp\",\n \"vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types(\",\n \"expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number\",\n \"query = \\\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL\",\n \"self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when applying the func 'x\",\n \"Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop\",\n \"= \\\"s were \\\" if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__(\",\n \"{\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x: float):\",\n \"power or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws\",\n \"( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total =\",\n \"number ln : natural logarithm log : logarithm log10 : base 10 logarithm\",\n \"vColumn category is date, False otherwise. Returns ------- bool True if the vColumn\",\n \"{} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT\",\n \"\\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations +=\",\n \"self.alias, self.alias, n ) title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using\",\n \"optional The integer k of the 'topk' method. new_category: str, optional The name\",\n \"0.000001: h = round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1))\",\n \"= -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent\",\n \"to check if Badr and Fouad are in the vColumn. You can write\",\n \"upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {}\",\n \"== 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax -\",\n \"optional Number of bins. If empty, an optimized number of bins will be\",\n \") else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---#\",\n \"(category in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category,\",\n \"self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history:\",\n \"when the parameter method is set to 'cat_stats'. Returns ------- tablesample An object\",\n \"for elem in self.transformations] total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]:\",\n \"____________ ______ # / __ `\\\\ / / # | \\\\/ / /\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float,\",\n \"= ( \\\"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({}\",\n \"p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\\\"Computing\",\n \"tanh : hyperbolic tangent x: int/float, optional If the function has two arguments\",\n \"entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data\",\n \"\\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ),\",\n \"---# def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"'same_freq'\\\" ) count = self.count() nb = int(float(count / int(nbins))) assert nb !=\",\n \"it is part of the DB version you are using. Returns ------- tablesample\",\n \"IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if\",\n \"self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the equal frequency\",\n \"{} using the MIN and the MAX. MAX = MIN !\\\".format( self.alias )\",\n \"str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0],\",\n \"1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias,\",\n \"\\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]})\",\n \") n = 1 if drop_first else 0 for k in range(len(distinct_elements) -\",\n \"-------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\",\",\n \"LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where,\",\n \"(\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by\",\n \"features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns categories.\",\n \"[\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\",\",\n \"for elem in result if elem[1] != None ] ), ) cmax =\",\n \"the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if the\",\n \"Warning) elif self.isnum(): if method == \\\"zscore\\\": if n == 0: nullifzero =\",\n \"of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn\",\n \"to True, the Median will be drawn. ax: Matplotlib axes object, optional The\",\n \"elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total)\",\n \"in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and\",\n \"top1 for the mode) topk_percent : kth most occurent element density unique :\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx,\",\n \"x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn\",\n \"'ts' is greater than November 1993 the 3rd. area: bool, optional If set\",\n \"vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns = [ column\",\n \"\\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def\",\n \"database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"datetime.date] = \\\"\\\", area: bool = False, step: bool = False, ax=None, **style_kwds,\",\n \"labels: list, optional Labels used to name the new categories. If empty, names\",\n \"if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\"\",\n \"--------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\"\",\n \"self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax,\",\n \"time series rule. Parameters ---------- length: int Slice size. unit: str, optional Slice\",\n \") for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] ==\",\n \"\\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the\",\n \"most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT {}\",\n \"elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 *\",\n \"of that relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias:\",\n \"{} was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str,\",\n \"ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot\",\n \"error of the mean skewness : skewness sum : sum std : standard\",\n \"input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({},\",\n \"\\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must be greater or equals\",\n \"+ 1] ... END odd : CASE ... WHEN vColumn = argv[2 *\",\n \"prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else 0 for k in\",\n \"if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1\",\n \"/ / # / / # / / # \\\\ / # \\\\\",\n \"the histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\",\",\n \"= \\\"(CASE \\\" for i in range(1, n): trans += \\\"WHEN {} BETWEEN\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---#\",\n \"self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if\",\n \"* sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in elem:\",\n \"False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie(\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method,\",\n \"self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\"\",\n \"regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if\",\n \"as categorical (No h will be picked or computed) ax: Matplotlib axes object,\",\n \"method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\":\",\n \"outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold,\",\n \"{}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha,\",\n \"limit: int, optional Number of elements to display. Returns ------- tablesample An object\",\n \"), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item in result], \\\"count\\\":\",\n \"\\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as e: raise QueryError(\",\n \"to sequentialize # data transformation operations, and offers beautiful graphical options. # #\",\n \"if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if\",\n \"if the absolute value of the record is greater than the threshold, it\",\n \"\\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"parameter 'name', you'll be able to solve this issue.\\\" ) new_vColumn = vColumn(\",\n \"the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the\",\n \"assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing the\",\n \"return trans else: self.transformations += [trans] sauv = {} for elem in self.catalog:\",\n \"{} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when =\",\n \"series rule. Parameters ---------- length: int Slice size. unit: str, optional Slice size\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---#\",\n \"BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__()\",\n \"\\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method:\",\n \"similar to the following: (function, type, category) parent: vDataFrame, optional Parent of the\",\n \"bool, optional If set to True, the Median will be drawn. ax: Matplotlib\",\n \"------- bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate :\",\n \"), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else:\",\n \"not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0]\",\n \"avg) / std robust_zscore : Normalization using the Robust Z-Score (median and mad).\",\n \"elif method == \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method 'robust_zscore'\",\n \"different aggregation. aad : average absolute deviation approx_unique : approximative cardinality count :\",\n \"{} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i -\",\n \"self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be\",\n \"\\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ]\",\n \"= \\\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {}\",\n \"__nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---#\",\n \"deviation topk : kth most occurent element (ex: top1 for the mode) topk_percent\",\n \"utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\"\",\n \"1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\",\",\n \") elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\"\",\n \"self, by: str = \\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\"\",\n \"self.parent.shape()[0] ) except: pass total = int(total) conj = \\\"s were \\\" if\",\n \"(\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int,\",\n \"\\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC\",\n \"= True if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of =\",\n \"drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not\",\n \"avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"[int, float])]) assert x != 0, ValueError(\\\"Division by 0 is forbidden !\\\") return\",\n \"Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest with 20\",\n \"/ n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns\",\n \"vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use to partition\",\n \"\\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---# def\",\n \"user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with\",\n \"the record is greater than the threshold, it will be considered as an\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the\",\n \"the optimal vColumn bar width. Parameters ---------- method: str, optional Method to use\",\n \"= self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of)\",\n \"val: list List of the different records. For example, to check if Badr\",\n \"the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority =\",\n \") except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent\",\n \"If set to True, the information will be stored in the vDataFrame history.\",\n \"'quantile'. Parameters ---------- x: float A float between 0 and 1 that represents\",\n \"executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype),\",\n \"of the record is greater than the threshold, it will be considered as\",\n \"= \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions\",\n \"Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors\",\n \"will be computed. pie_type: str, optional The type of pie chart. auto :\",\n \"elif fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif\",\n \"for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix)\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def\",\n \"self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list = [], include_lowest:\",\n \"of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also\",\n \"to impute the vColumn. method: dict, optional Method to use to impute the\",\n \"itself and the values higher than the upper bound to the upper bound\",\n \"the list will be included. right: bool, optional How the intervals should be\",\n \"str, optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"--------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x: float If\",\n \"()) AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {}\",\n \"the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct categories\",\n \"= self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date,\",\n \"# ---# def cut( self, breaks: list, labels: list = [], include_lowest: bool\",\n \"0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int,\",\n \"+= [name] conj = \\\"s were \\\" if len(all_new_features) > 1 else \\\"\",\n \"vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing one of \\\"\",\n \"Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x,\",\n \"op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l,\",\n \"\\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),\",\n \"1.01 / nbins if h > 0.01: h = round(h, 2) elif h\",\n \"return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self):\",\n \"if ((is_date) and not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ):\",\n \"new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates\",\n \"if total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) +\",\n \"by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\",\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT\",\n \"0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters\",\n \"\\\\_______/ / / # ______ / / # \\\\ / / / #\",\n \"\\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False,\",\n \"{} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin =\",\n \"the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(),\",\n \"ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =\",\n \"using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from\",\n \"def fillna( self, val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\", by:\",\n \"PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25)\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used are\",\n \"# |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # / __ `\\\\\",\n \"= \\\"auto\\\", h: float = 0, nbins: int = -1, k: int =\",\n \"optimized number of bins will be computed. h: float, optional Interval width of\",\n \"if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if len(cat) == 1:\",\n \"\\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must\",\n \"= \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\",\",\n \"the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query =\",\n \"Sets the method to 'numerical' if the vColumn is numerical , 'categorical' otherwise.\",\n \"/ ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE /\",\n \"breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\",\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"-------- vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\" check_types( [ (\",\n \"vColumn to use to partition the data. h: float, optional Interval width if\",\n \"\\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column if\",\n \"a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the\",\n \"mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN {}\",\n \"from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"]\",\n \": Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins,\",\n \"None if not (result) else result[0][0] if not (dropna): n = \\\"\\\" if\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert\",\n \"was applied to the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info )\",\n \"__len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---#\",\n \"/ spatial / uuid / undefined Returns ------- str vColumn category. See Also\",\n \"for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in\",\n \"\\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column =\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx,\",\n \"vColumn 'of'. min : Minimum of the vColumn 'of'. max : Maximum of\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns,\",\n \"# ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns -------\",\n \"= [ ( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\"\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"= \\\"s were \\\" if total > 1 else \\\" was \\\" if\",\n \"\\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, }\",\n \"specific TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]),\",\n \"merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the\",\n \"the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def\",\n \"if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN\",\n \"Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name\",\n \"of the input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by,\",\n \") query = \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ())\",\n \"series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\"\",\n \"date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn\",\n \"Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" #\",\n \"optional List of the vColumns to use to sort the data when using\",\n \"vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT\",\n \"Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__(\",\n \"input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See\",\n \"can have multiple children vColumns whereas one vColumn can only have one parent.\",\n \"in ffill|pad|bfill|backfill then 'order_by' must be a list of at least one element\",\n \"iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins,\",\n \"== None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None)\",\n \"to True, the record will be sliced using the floor of the slicing\",\n \"from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\":\",\n \"set to 'smart'. A RF Regressor will be trained if the response is\",\n \"verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name =\",\n \"name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp\",\n \"columns += [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"]\",\n \"values higher than the upper bound to the upper bound itself. Parameters ----------\",\n \"method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of\",\n \"(SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title =\",\n \"approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie(\",\n \"the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float =\",\n \") for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value,\",\n \"optional Drops the first dummy to avoid the creation of correlated features. use_numbers_as_suffix:\",\n \"[\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ]\",\n \"executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count,\",\n \"and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be\",\n \"gen_colors() if not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax\",\n \"Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax = self.max()\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar :\",\n \"!= None else \\\"NULL\\\", ) for elem in result if elem[1] != None\",\n \"if n > 0: warning_message = \\\"The method 'robust_zscore' is available only if\",\n \"data. The vColumn type must be date like (date, datetime, timestamp...) or numerical.\",\n \"is returned. By setting this parameter to False, the function's performance can drastically\",\n \"Parameters ---------- limit: int, optional Number of elements to display. Returns ------- tablesample\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If\",\n \"str Function to use to transform the vColumn. abs : absolute value acos\",\n \"alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the\",\n \"in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} =\",\n \"will return the mode of the vColumn. Returns ------- str/float/int vColumn nth most\",\n \"return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int\",\n \"partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count\",\n \"elements cvar : conditional value at risk dtype : vColumn type iqr :\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression in each\",\n \"{name}.\\\\nBy changing the parameter 'name', you'll be able to solve this issue.\\\" )\",\n \"= self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary to\",\n \"{};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See\",\n \"BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query),\",\n \"Propagation of the next element (Constant Interpolation). ffill : Propagation of the first\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return pre_comp\",\n \"already the alias of one of the dummies ({name}).\\\\n\\\" \\\"It can be the\",\n \"numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of parameter\",\n \"* i] THEN argv[2 * i + 1] ... END odd : CASE\",\n \"len( self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations\",\n \"return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count'\",\n \"---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the\",\n \"else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{},\",\n \"check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() ==\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def\",\n \"---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float\",\n \"vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1,\",\n \"new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif\",\n \"return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None))\",\n \") top = None if not (result) else result[0][0] if not (dropna): n\",\n \"vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify outliers.\",\n \"Matplotlib axes object, optional The axes to plot on. **style_kwds Any optional parameter\",\n \"percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS\",\n \"END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ),\",\n \"will filter the data when 'ts' is lesser than November 1993 the 3rd.\",\n \"must be date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple\",\n \"len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k\",\n \"self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input\",\n \"Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a response.\",\n \"using 'count' (Number of non-Missing elements). Returns ------- int number of non-Missing elements.\",\n \"See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\" if\",\n \"set to True, the approximate median is returned. By setting this parameter to\",\n \"USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category,\",\n \"information will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See\",\n \"suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also --------\",\n \"''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum()\",\n \"bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query + rp] query\",\n \"NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM\",\n \"check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)),\",\n \"if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return\",\n \"using the input functions. Parameters ---------- func: list List of the different aggregation.\",\n \"= \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\",\",\n \"vDataFrame[].tail : Returns the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) #\",\n \"using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the\",\n \"values will not be considered during the computation. n: int, optional Integer corresponding\",\n \"Parameters ---------- limit: int, optional Number of elements to display. offset: int, optional\",\n \"result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h\",\n \"# ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping\",\n \"object See Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [\",\n \"the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [\",\n \"was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features)\",\n \"vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \"to compute the best splits when 'method' is set to 'smart'. A RF\",\n \"self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for\",\n \"str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool\",\n \"vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \"method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be\",\n \"( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr =\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\",\",\n \"self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"self.parent See Also -------- vDataFrame.case_when : Creates a new feature by evaluating some\",\n \"= int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\" if\",\n \"1], result[i] ) trans += \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\",\",\n \"\\\"_\\\") ) n = 1 if drop_first else 0 for k in range(len(distinct_elements)\",\n \"---# def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic\",\n \"index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit\",\n \"{} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" )\",\n \"Computes statistics of a numerical column for each vColumn category. In this case,\",\n \"example, time = '03-11-1993' will filter the data when 'ts' is greater than\",\n \"+= [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias)\",\n \"mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def fillna( self, val=None, method:\",\n \"sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif\",\n \"\\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", ) for elem in result\",\n \"response: str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"Parameters ---------- start: int Start of the slicing. step: int Size of the\",\n \"== []: if fun == \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\":\",\n \"category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans =\",\n \"+= [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn\",\n \"( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\"\",\n \"{})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x,\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics.\",\n \"# You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0\",\n \"< {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = (\",\n \"# VerticaPy is a Python library with scikit-like functionality for conducting # data\",\n \"simplify several processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations:\",\n \"--------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an aggregation. Parameters\",\n \"LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} largest\",\n \"nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start: int, step:\",\n \"int = 6, nbins: int = 0, h: float = 0, ax=None, **style_kwds,\",\n \"n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number\",\n \"code generation will be slower if the vDataFrame has been transformed multiple times,\",\n \") for elem in result if elem[1] != None ] ), ) stddev\",\n \"sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"]\",\n \"current axes. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"+= [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k)\",\n \"self.alias) query = \\\"SELECT {} AS {}, {} AS ord, {}::int AS {}\",\n \"min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS\",\n \"function's performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality).\",\n \"to the next whole number ln : natural logarithm log : logarithm log10\",\n \"by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"Draws the Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"= \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn\",\n \"a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"# ---# def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the\",\n \"start_or_end ) ) # ---# def spider( self, by: str = \\\"\\\", method:\",\n \"is numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is\",\n \"), ) else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the\",\n \"element to the vColumn. Parameters ---------- x: float If the vColumn type is\",\n \"if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] =\",\n \"\\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] #\",\n \"0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop +=\",\n \"# \\\\_______/ / / # ______ / / # \\\\ / / /\",\n \"q quantile (ex: 50% for the median) prod : product range : difference\",\n \"size unit. For example, it can be 'minute' 'hour'... start: bool, optional If\",\n \"elif elem == None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] =\",\n \": Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q,\",\n \"regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular\",\n \"h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \"breaks: list, labels: list = [], include_lowest: bool = True, right: bool =\",\n \"vColumn. nbins: int, optional Maximum number of nbins used for the discretization (must\",\n \"of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll\",\n \"float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"---------- *args / **kwargs Any optional parameter to pass to the geopandas plot\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers\",\n \"{} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\"\",\n \"/ NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events\",\n \"1.4826 if mad != 0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias,\",\n \"matches for the regular expression in each record of the vColumn. The vColumn\",\n \"for numerical vColumns, cast the other types to varchar. same_freq : Computes bins\",\n \"\\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"{} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR\",\n \"self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the\",\n \"* from verticapy.toolbox import * from verticapy.errors import * ## # # __\",\n \"with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\",\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0]\",\n \"for elem in result if elem[2] != None ] ), ) executeSQL( \\\"SELECT\",\n \"using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not be\",\n \"- len( self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT\",\n \"to [0, n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame\",\n \"# ---# def describe( self, method: str = \\\"auto\\\", max_cardinality: int = 6,\",\n \"value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({},\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ----------\",\n \"if the vColumn is numerical or of type date like. Optimized h will\",\n \"OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count\",\n \"None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input\",\n \"k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how\",\n \"whole number cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric\",\n \"\\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0\",\n \"cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if\",\n \"to use to compute the aggregation. h: int/float/tuple, optional Interval width of the\",\n \"+ [self.max()] elif method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k'\",\n \"sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total # ---#\",\n \"the vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular expression.\",\n \"(upper != None), ParameterError( \\\"At least 'lower' or 'upper' must have a numerical\",\n \"copy_name: str, optional If not empty, a copy will be created using the\",\n \"of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\",\",\n \"vColumn {} named {} was added to the vDataFrame.\\\".format( self.alias, name ) )\",\n \"Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on an\",\n \"1\\\") where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else\",\n \"{} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) )\",\n \"KIND, either express or implied. # See the License for the specific language\",\n \"self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe\",\n \"self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the input type.\",\n \"h will be computed. pie_type: str, optional The type of pie chart. auto\",\n \"encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters\",\n \"\\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\\",\n \"def boxplot( self, by: str = \\\"\\\", h: float = 0, max_cardinality: int\",\n \"\\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query\",\n \"mode : mode (most occurent element). 0ifnull : 0 when the vColumn is\",\n \"min sem : standard error of the mean skewness : skewness sum :\",\n \"the regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices the\",\n \"/ uuid / undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype\",\n \"in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({})\",\n \": Draws the donut chart of the vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format(\",\n \"THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events =\",\n \"you'll be able to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__(\",\n \"e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format( e,\",\n \"2 to be used as categorical (No h will be picked or computed)\",\n \"vColumn using 'sem' (standard error of mean). Returns ------- float sem See Also\",\n \"respective average. null : Replaces the outliers by the NULL value. winsorize :\",\n \"method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ],\",\n \"order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] +\",\n \"of the vColumn. The category will be one of the following: date /\",\n \"assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" )\",\n \"of parameter 'labels' + 1 or parameter 'labels' must be empty.\\\" ) conditions,\",\n \"vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True\",\n \"number of nbins used for the discretization (must be > 1) Returns -------\",\n \"---------- ts: str TS (Time Series) vColumn to use to order the data.\",\n \"(1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [\",\n \"= method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool():\",\n \"in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies(\",\n \"Interval width if the vColumn is numerical or of type date like. Optimized\",\n \"using the Z-Score (avg and std). (x - avg) / std robust_zscore :\",\n \"0: if nbins <= 0: h = self.numh() else: h = (self.max() -\",\n \"method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category()\",\n \"optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem\",\n \"/ {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation\",\n \": Returns the head of the vColumn. vDataFrame[].tail : Returns the tail of\",\n \": median absolute deviation max : maximum mean : average median : median\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool\",\n \"\\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] =\",\n \"date like. Optimized h will be computed if the parameter is empty or\",\n \"when 'method' is set to 'smart'. A RF Regressor will be trained if\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str, optional\",\n \"tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM\",\n \"dropping the current vColumn and creating a copy with the specified name. \\\\u26A0\",\n \"str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn.\",\n \"BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\"\",\n \"cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers\",\n \"\\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else:\",\n \"lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution to define\",\n \"parameter method is set to 'cat_stats'. Returns ------- tablesample An object containing the\",\n \"self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name: str\",\n \"the vColumn to the input type. Parameters ---------- dtype: str New type. Returns\",\n \"for item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False )\",\n \"\\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method =\",\n \"categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info\",\n \"str = \\\"\\\", max_cardinality: int = 6, nbins: int = 0, h: float\",\n \"and transforms the vColumn using a time series rule. Parameters ---------- length: int\",\n \"empty, an optimized number of nbins will be computed. h: float, optional Interval\",\n \"upper_when = ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if\",\n \"and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must\",\n \"for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count,\",\n \"\\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for\",\n \"vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate :\",\n \"sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns\",\n \"= \\\"The method 'robust_zscore' is available only if the parameter 'by' is empty\\\\nIf\",\n \"by the input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame\",\n \"vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {}\",\n \"\\\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()),\",\n \"FLOOR({} / {}) * {} || ';' || (FLOOR({} / {}) * {}\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"nth_elems = nb, [], [] while total < int(float(count / int(nbins))) * int(nbins):\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws\",\n \"set to False else the lower and upper ZScores. threshold: float, optional Uses\",\n \"TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\",\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The\",\n \"NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS\",\n \"title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def\",\n \"represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter\",\n \"to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object See\",\n \"customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\",\",\n \"and the min sem : standard error of the mean skewness : skewness\",\n \"top = None if not (result) else result[0][0] if not (dropna): n =\",\n \"else \\\"NULL\\\", ) for elem in result if elem[1] != None ] ),\",\n \"\\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor\",\n \"of bins. If empty, an optimized number of bins will be computed. h:\",\n \"== \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({})\",\n \"== \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert\",\n \"self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by\",\n \"{op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN\",\n \") setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features +=\",\n \"- 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also\",\n \"See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers :\",\n \"\\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ #\",\n \"of the first element (Constant Interpolation). mean : Average. median : median. mode\",\n \"] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0: if nbins\",\n \"current vColumn and creating a copy with the specified name. \\\\u26A0 Warning :\",\n \"trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential\",\n \"20 trees and a maximum depth of 10. response: str, optional Response vColumn\",\n \"{}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can\",\n \"0: column = args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check\",\n \"by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by =\",\n \"method: str, optional Method to use to normalize. zscore : Normalization using the\",\n \"= \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method ==\",\n \"int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025)\",\n \"for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] =\",\n \"AVG(column1) + 5). of: str, optional The vColumn to use to compute the\",\n \"== None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\",\",\n \"(isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when,\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({}) OVER\",\n \"Size of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"/ self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) )\",\n \"will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills\",\n \") return top # ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the\",\n \"argv: object Any amount of expressions. The expression generated will look like: even:\",\n \"\\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, )\",\n \"NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n )\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError\",\n \"to partition the data. h: float, optional Interval width if the vColumn is\",\n \"NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations\",\n \"self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset\",\n \"Micro Focus or one of its affiliates. # Licensed under the Apache License,\",\n \"discretization (must be > 1) k: int, optional The integer k of the\",\n \"Draws the range plot of the vColumn. The aggregations used are the median\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]),\",\n \"will be sliced using the floor of the slicing instead of the ceiling.\",\n \"values used to cut the vColumn. labels: list, optional Labels used to name\",\n \"= gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp =\",\n \"set to True, NULL values will not be considered during the computation. n:\",\n \"Parameters ---------- to_replace: str Regular expression to replace. value: str, optional New value.\",\n \"breaks: list List of values used to cut the vColumn. labels: list, optional\",\n \"LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER\",\n \"tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot.\",\n \"NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result =\",\n \"# Special Methods # # ---# def __init__( self, alias: str, transformations: list\",\n \"by: str = \\\"\\\", h: float = 0, max_cardinality: int = 8, cat_priority:\",\n \") else: final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg,\",\n \"# ---# def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"\\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem\",\n \"of the list will be included. right: bool, optional How the intervals should\",\n \"FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE\",\n \"data. # # # Modules # # Standard Python Modules import math, re,\",\n \"[by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans,\",\n \"re, decimal, warnings, datetime from collections.abc import Iterable from typing import Union #\",\n \"- sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"]\",\n \"threshold it will be considered as an outlier. use_threshold: bool, optional Uses the\",\n \"approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x\",\n \"range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) #\",\n \"chart. rose : Rose chart. It can also be a cutomized aggregation (ex:\",\n \"discretization using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not\",\n \"\\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\",\n \"= RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try:\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"= 6, nbins: int = 0, h: float = 0, ax=None, **style_kwds, ):\",\n \"filled.\\\") self.transformations = [elem for elem in copy_trans] for elem in sauv: self.catalog[elem]\",\n \"\\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method ==\",\n \"\\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number\",\n \"category is date, False otherwise. Returns ------- bool True if the vColumn category\",\n \"draw an Area Plot. step: bool, optional If set to True, draw a\",\n \"Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman\",\n \"{} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column =\",\n \"Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"\\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the\",\n \"query, title=\\\"Computing the top{} categories of {}.\\\".format( k if k > 0 else\",\n \"\\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for i in\",\n \"\\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] +=\",\n \"November 1993 the 3rd. plot_median: bool, optional If set to True, the Median\",\n \"get the median). It can also be a cutomized aggregation (ex: AVG(column1) +\",\n \"use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1],\",\n \"\\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query =\",\n \"= True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using\",\n \"statistical information. Parameters ---------- k: int, optional Number of most occurent elements to\",\n \"max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in\",\n \"all user transformations. If the vDataFrame represents the entire relation, a vColumn can\",\n \"be equal to the length of parameter 'labels' + 1 or parameter 'labels'\",\n \"\\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by]\",\n \"type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad\",\n \"spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) #\",\n \"else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2}\",\n \"\\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name,\",\n \"self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True,\",\n \"Fills missing elements in the vColumn with a user-specified rule. Parameters ---------- val:\",\n \"n ) title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title)\",\n \"*argv)) # ---# def density( self, by: str = \\\"\\\", bandwidth: float =\",\n \"bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also --------\",\n \"the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies\",\n \"------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() -\",\n \"under the Apache License, Version 2.0 (the \\\"License\\\"); # You may not use\",\n \"vDataFrame by using an advanced analytical function on a specific vColumn. \\\"\\\"\\\" return\",\n \"final_transformation = [ ( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin,\",\n \"more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM\",\n \"with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes\",\n \"if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum():\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the\",\n \"ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title =\",\n \"occurent elements to return. dropna: bool, optional If set to True, NULL values\",\n \"variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info =\",\n \"vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use\",\n \"elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check = False if check:\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \\\"\\\", h: float\",\n \"n, [int, float])]) query = \\\"SELECT * FROM {} WHERE {} IS NOT\",\n \"be used as categorical (No h will be picked or computed) ax: Matplotlib\",\n \"count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min)\",\n \"lesser than November 1993 the 3rd. end_date: str / date, optional Input End\",\n \"regular expression in each record of the vColumn. The vColumn will be transformed.\",\n \"True, draw an Area Plot. step: bool, optional If set to True, draw\",\n \"(nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation = [ ( \\\"({} -\",\n \"optional List of the different categories to consider when drawing the box plot.\",\n \"vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start,\",\n \"Drops the vColumn from the vDataFrame. Dropping a vColumn means simply not selecting\",\n \"AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"= 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if\",\n \"set to True, the record will be sliced using the floor of the\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] )\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns -------\",\n \"self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in\",\n \"parameter will increase the precision but will also increase the time of the\",\n \"the outliers. After normalizing the data (Z-Score), if the absolute value of the\",\n \"the record will be sliced using the floor of the slicing instead of\",\n \"when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest\",\n \"optional parameter to pass to the geopandas plot function. For more information, see:\",\n \"import pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds,\",\n \"new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {} AS ord,\",\n \"(SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT\",\n \"bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input\",\n \"func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str):\",\n \"Parameters ---------- approx: bool, optional If set to True, the approximate median is\",\n \"---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns\",\n \"text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements))\",\n \"n smallest elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns\",\n \") ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias, dtype\",\n \"min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {})\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance = var\",\n \"the vColumn DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower()\",\n \"str = \\\"auto\\\", h: float = 0, nbins: int = -1, k: int\",\n \"check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\",\",\n \"vColumn {} has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"== \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\"\",\n \"[bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self,\",\n \"= \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN {} >\",\n \"Dictionary of the Random Forest model parameters used to compute the best splits\",\n \"categorical. The less frequent elements will be gathered together to create a new\",\n \": natural logarithm log : logarithm log10 : base 10 logarithm mod :\",\n \"pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---#\",\n \"itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper bound.\",\n \"to determine if the vColumn will be considered as categorical. numcol: str, optional\",\n \"- 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2,\",\n \"columns = [self.alias] check = True if len(args) > 0: column = args[0]\",\n \"if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs):\",\n \"'breaks' must be greater or equal to 2.\\\" ) assert len(breaks) == len(labels)\",\n \"(\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type ==\",\n \"the vColumn using a time series rule. Parameters ---------- length: int Slice size.\",\n \"index_stop - index_start if limit <= 0: limit = 0 limit = \\\"\",\n \"(Time Series) vColumn to use to order the data. The vColumn type must\",\n \"moving # data around for processing, VerticaPy brings the logic to the data.\",\n \"chart of the vColumn based on an aggregation. Parameters ---------- method: str, optional\",\n \"n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters\",\n \"parameter 'breaks' must be greater or equal to 2.\\\" ) assert len(breaks) ==\",\n \"of the different transformations. Each transformation must be similar to the following: (function,\",\n \"optional Number of bins used for the discretization (must be > 1) k:\",\n \"\\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result],\",\n \"result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0],\",\n \"float]), (\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"the vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount of\",\n \"mean : Average. median : median. mode : mode (most occurent element). 0ifnull\",\n \") # ---# def spider( self, by: str = \\\"\\\", method: str =\",\n \"try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}',\",\n \"\\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] =\",\n \"check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method\",\n \"to use to order the data\\\" ) desc = \\\"\\\" if (method in\",\n \") if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\")\",\n \"method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else\",\n \"'of'. sum : Sum of the vColumn 'of'. q% : q Quantile of\",\n \"best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if\",\n \"# ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns -------\",\n \"the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by:\",\n \"mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from\",\n \"by applicable law or agreed to in writing, software # distributed under the\",\n \"kernel. kernel: str, optional The method used for the plot. gaussian : Gaussian\",\n \"{} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different\",\n \") elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS\",\n \"to keep after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"if drop_first else 0 for k in range(len(distinct_elements) - n): name = (\",\n \"methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn\",\n \"---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns -------\",\n \"in case of discretization using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter\",\n \"= \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT\",\n \"\\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] =\",\n \"the different transformations. Each transformation must be similar to the following: (function, type,\",\n \"If set to True, the Median will be drawn. ax: Matplotlib axes object,\",\n \"of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype #\",\n \"method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import\",\n \"print(\\\"The mean encoding was successfully done.\\\") return self.parent # ---# def median( self,\",\n \"/ int / float / text / binary / spatial / uuid /\",\n \"0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT\",\n \"int, optional Number of bins. If empty, an optimized number of bins will\",\n \"\\\"Parameter 'nbins' must be greater or equals to 2 in case of discretization\",\n \") order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column =\",\n \"to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\",\",\n \"+ ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a\",\n \"to_tablesample(query, title=title) # ---# def normalize( self, method: str = \\\"zscore\\\", by: list\",\n \"the median and two input quantiles. Parameters ---------- ts: str TS (Time Series)\",\n \"mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"int, optional Number of most occurent elements to return. dropna: bool, optional If\",\n \"graphical options. # # VerticaPy aims to do all of the above. The\",\n \"= [], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in\",\n \"[(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed\",\n \"argv[2 * i] THEN argv[2 * i + 1] ... ELSE argv[n] END\",\n \"selecting it in the final generated SQL code. Note: Dropping a vColumn can\",\n \"otherwise. expr: str, optional SQL expression. by: list, optional vColumns used in the\",\n \"fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by == []:\",\n \"vColumn DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype\",\n \"] ) method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The\",\n \"total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except:\",\n \"best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool =\",\n \"store usage (unit: b). Returns ------- int vColumn expected store usage. See Also\",\n \"get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias,\",\n \"upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers\",\n \"the computation. n: int, optional Integer corresponding to the offset. For example, if\",\n \"# ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr]\",\n \"return self.parent # ---# def fillna( self, val=None, method: str = \\\"auto\\\", expr:\",\n \"if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] #\",\n \"a part of the vColumn (delimited by an offset and a limit). Parameters\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional\",\n \"AS woe, CASE WHEN non_events = 0 OR events = 0 THEN 0\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---#\",\n \"*args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs\",\n \"-------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \\\"\\\"\\\" if\",\n \"The method to use to aggregate the data. count : Number of elements.\",\n \"to False, the function's performance can drastically decrease. Returns ------- float quantile (or\",\n \"2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) **\",\n \"[float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import\",\n \"an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method,\",\n \"# ---# def topk(self, k: int = -1, dropna: bool = True): \\\"\\\"\\\"\",\n \"optimised interval will be computed. nbins: int, optional Number of bins used for\",\n \"Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the\",\n \"a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self,\",\n \"+ 1) query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(),\",\n \") if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {}\",\n \"str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\",\",\n \"category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will be\",\n \"the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self,\",\n \"its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List of\",\n \"FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS\",\n \"Fills the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]),\",\n \"the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns -------\",\n \": Mean for the numerical and Mode for the categorical vColumns. bfill :\",\n \"item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] +=\",\n \"the following: CENTURY / DAY / DECADE / DOQ / DOW / DOY\",\n \"plot. The other categories will be filtered. ax: Matplotlib axes object, optional The\",\n \"the kernel. kernel: str, optional The method used for the plot. gaussian :\",\n \"else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional\",\n \"SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT\",\n \"the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See Also\",\n \"import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds,\",\n \"= pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"a Python library with scikit-like functionality for conducting # data science projects on\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x: float\",\n \"vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, )\",\n \"the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage\",\n \"limit: int, optional Number of elements to display. offset: int, optional Number of\",\n \"self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers\",\n \"(IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y)\",\n \"({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\",\",\n \"by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"/ WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice :\",\n \"the vColumn outliers. mean : Replaces the upper and lower outliers by their\",\n \"DB version you are using. Returns ------- tablesample An object containing the result.\",\n \"topk : kth most occurent element (ex: top1 for the mode) topk_percent :\",\n \"may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # #\",\n \"\\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column\",\n \"---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"float, optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent\",\n \"float])]) assert x != 0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{}\",\n \"-------- vDataFrame.isin : Looks if some specific records are in the vDataFrame. \\\"\\\"\\\"\",\n \"method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int,\",\n \"return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial\",\n \"or of type date like. Optimized h will be computed if the parameter\",\n \"column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot\",\n \"h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis\",\n \"Parameters ---------- by: str, optional vColumn to use to partition the data. method:\",\n \"Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def\",\n \"during the computation. cat_stats : Computes statistics of a numerical column for each\",\n \"# ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to\",\n \"distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool():\",\n \"k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func,\",\n \"Maximum number of nbins used for the discretization (must be > 1) Returns\",\n \"sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See\",\n \"response, ParameterError( \\\"Parameter 'response' can not be empty in case of discretization using\",\n \"0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self,\",\n \"\\\\_/|_|(_||| # / # ____________ ______ # / __ `\\\\ / / #\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int,\",\n \"only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr\",\n \"discretization\\\" ) total, query, nth_elems = nb, [], [] while total < int(float(count\",\n \"with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode :\",\n \"and method == \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ): n\",\n \"not normalize {} using a Robust Z-Score - The MAD is null !\\\".format(\",\n \"VerticaPy aims to do all of the above. The idea is simple: instead\",\n \": Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] #\",\n \"uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful\",\n \"that stores all user transformations. If the vDataFrame represents the entire relation, a\",\n \"and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha\",\n \"be > 1) Returns ------- tablesample An object containing the result. For more\",\n \"[ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date,\",\n \"to 2 in case of discretization using the method 'same_freq'\\\" ) count =\",\n \"new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {}\",\n \"places sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic sine\",\n \"of the above. The idea is simple: instead of moving # data around\",\n \"dict, optional Catalog where each key corresponds to an aggregation. vColumns will memorize\",\n \"CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i +\",\n \"drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if\",\n \"int, optional Maximum number of points to use to evaluate the approximate density\",\n \"str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies\",\n \"== \\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if\",\n \"method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else\",\n \"allow slicing having steps different than 1.\\\" ) index_stop = index.stop index_start =\",\n \"result except: model.drop() raise # ---# def describe( self, method: str = \\\"auto\\\",\",\n \"relevant interval to use for the discretization. topk : Keeps the topk most\",\n \"try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format(\",\n \"______ # / __ `\\\\ / / # | \\\\/ / / /\",\n \"def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise.\",\n \"the min sem : standard error of the mean skewness : skewness sum\",\n \"max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format(\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return\",\n \"and 1 that represents the quantile. For example: 0.25 represents Q1. approx: bool,\",\n \"data when 'ts' is greater than November 1993 the 3rd. plot_median: bool, optional\",\n \"percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias,\",\n \"\\\\/ / / / # |______ / / / # |____/ / /\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ----------\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\",\",\n \"self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations\",\n \") ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations)\",\n \"Replaces the outliers by the NULL value. winsorize : Clips the vColumn using\",\n \"---------- limit: int, optional Number of elements to display. offset: int, optional Number\",\n \"+ \\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self, limit:\",\n \"\\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n =\",\n \"vColumn and it returns the new vDataFrame of the search. Parameters ---------- val:\",\n \"text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"),\",\n \"\\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if\",\n \"use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\",\",\n \"this case, the parameter 'numcol' must be defined. numerical : Uses popular numerical\",\n \"to return. dropna: bool, optional If set to True, NULL values will not\",\n \"null : Replaces the outliers by the NULL value. winsorize : Clips the\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness\",\n \"\\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [\",\n \"uuid / undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype :\",\n \"False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ----------\",\n \"isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means simply\",\n \"or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See Also\",\n \"ParameterError( \\\"Parameter 'nbins' must be greater or equals to 2 in case of\",\n \"expressions. The expression generated will look like: even: CASE ... WHEN vColumn =\",\n \"vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\"\",\n \"Average of the vColumn 'of'. min : Minimum of the vColumn 'of'. max\",\n \"of the vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn.\",\n \"\\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT\",\n \"vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def __len__(self): return\",\n \"= breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r = \\\"<\\\",\",\n \"vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation\",\n \"to train a Random Forest with 20 trees and a maximum depth of\",\n \"self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent\",\n \"the max and the min sem : standard error of the mean skewness\",\n \"BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self):\",\n \"FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result =\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"),\",\n \") index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start =\",\n \"warnings.warn(warning_message, Warning) return self elif n == 1: try: result = executeSQL( \\\"SELECT\",\n \"the different categories to consider when drawing the box plot. The other categories\",\n \"\\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"]\",\n \"drastically decrease. Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate\",\n \"# ---# def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"= {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"NULL values will not be considered during the computation. n: int, optional Integer\",\n \"---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns -------\",\n \"mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"== \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for\",\n \"empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns\",\n \"range(1, n): trans += \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format(\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool\",\n \"______ / / # \\\\ / / / # \\\\ / / /\",\n \"vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in\",\n \"keep after the comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \") return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if\",\n \"for testing to be able to look at the final transformation. Returns -------\",\n \"the distribution. mean : Average of the vColumn 'of'. min : Minimum of\",\n \"often they occur, and other statistical information. Parameters ---------- k: int, optional Number\",\n \"empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to\",\n \"model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---#\",\n \"speed and built-in analytics and machine learning features. It supports the # entire\",\n \"optional vColumn to use to partition the TS. start_date: str / date, optional\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the\",\n \"== len(labels) + 1 or not (labels), ParameterError( \\\"Length of parameter breaks must\",\n \"vColumn by transforming the values lesser than the lower bound to the lower\",\n \"case, the parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations\",\n \"else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\":\",\n \"SQL code generation will be slower if the vDataFrame has been transformed multiple\",\n \"int, optional Maximum number of vColumn distinct elements to be used as categorical.\",\n \"query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist\",\n \"--------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int, optional Offset.\",\n \": cube root ceil : value up to the next whole number cos\",\n \"Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed under the\",\n \"\\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"lowest element of the list will be included. right: bool, optional How the\",\n \"name: str Name of the copy. Returns ------- vDataFrame self.parent See Also --------\",\n \"max). (x - min) / (max - min) by: list, optional vColumns used\",\n \"# \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # #\",\n \"HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS\",\n \"ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"{} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg,\",\n \"alias {name}.\\\\nBy changing the parameter 'name', you'll be able to solve this issue.\\\"\",\n \"------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes\",\n \"date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must\",\n \"\\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"]\",\n \"\\\"median\\\") else \\\"AVG\\\" if by == []: if fun == \\\"AVG\\\": val =\",\n \"this parameter is equal to 0, an optimised interval will be computed. nbins:\",\n \"{} must be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert\",\n \"datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ),\",\n \"use to partition the data. bandwidth: float, optional The bandwidth of the kernel.\",\n \"NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {}\",\n \"It is only valid if the vColumns are numerical. Optimized h will be\",\n \") query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", )\",\n \"- total) except Exception as e: self.transformations = [elem for elem in copy_trans]\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None):\",\n \"{}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {},\",\n \"Uses the Gaussian distribution to define the outliers. After normalizing the data (Z-Score),\",\n \"specific language governing permissions and # limitations under the License. # # |_\",\n \"parent # ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by\",\n \"{} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT\",\n \"the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp !=\",\n \"aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]),\",\n \"response: str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the\",\n \"= False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method.\",\n \"\\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ],\",\n \"Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result\",\n \"and upper ZScores. threshold: float, optional Uses the Gaussian distribution to define the\",\n \"if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if\",\n \"\\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/\",\n \"parameter 'x' will represent the number of seconds, otherwise it will represent a\",\n \"alpha: float, optional Number representing the outliers threshold. Values lesser than quantile(alpha) or\",\n \"the threshold instead of the 'alpha' parameter. alpha: float, optional Number representing the\",\n \"\\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\",\",\n \"y: str Response vColumn. nbins: int, optional Maximum number of nbins used for\",\n \"= 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna:\",\n \"/ / # \\\\/ / / # / / # / / #\",\n \"int = 6, h: float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds,\",\n \"sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root\",\n \"method: str, optional Method to use to compute the optimal h. auto :\",\n \"try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop()\",\n \"vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If the\",\n \"use to partition the data. method: str, optional The method to use to\",\n \"---------- alias: str vColumn alias. transformations: list, optional List of the different transformations.\",\n \"val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\"\",\n \"float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\",\",\n \"number of the vColumn distinct elements to be used as categorical (No h\",\n \"func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value: str\",\n \"(\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"vColumn will be transformed. Parameters ---------- field: str The field to extract. It\",\n \"[int, float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr\",\n \"taking advantage Vertica’s # speed and built-in analytics and machine learning features. It\",\n \"of the merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary\",\n \"'upper' must have a numerical value\\\" ) lower_when = ( \\\"WHEN {} <\",\n \"{2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE\",\n \"the vColumn type is date like (date, datetime ...), the parameter 'x' will\",\n \"[ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]),\",\n \"False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters\",\n \"None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join(\",\n \"vColumn using 'median'. Parameters ---------- approx: bool, optional If set to True, the\",\n \"), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\":\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"the function: x -> x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name:\",\n \"matches in each of the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\",\",\n \"if Badr and Fouad are in the vColumn. You can write the following\",\n \"for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({})\",\n \"[int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\",\",\n \"Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history,\",\n \"h = (self.max() - self.min()) * 1.01 / nbins if h > 0.01:\",\n \"0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for\",\n \"assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be\",\n \"(\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero,\",\n \"values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val\",\n \"vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \": kth most occurent element density unique : cardinality (count distinct) var :\",\n \"\\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method ==\",\n \": Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name =\",\n \"= 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%',\",\n \"transforming the values lesser than the lower bound to the lower bound itself\",\n \"= result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"):\",\n \"the License for the specific language governing permissions and # limitations under the\",\n \"is available only if the parameter 'by' is empty\\\\nIf you want to normalize\",\n \"[ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(\",\n \") self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\",\",\n \"= int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) /\",\n \"the data when using TS methods. Returns ------- vDataFrame self.parent See Also --------\",\n \"vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns the tail\",\n \"(numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column if the method\",\n \"transformed. Parameters ---------- field: str The field to extract. It must be one\",\n \"an outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter.\",\n \"the vColumns are numerical. Optimized h will be computed if the parameter is\",\n \"\\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self,\",\n \"be greater or equal to 1\\\") where = \\\" WHERE {} IS NOT\",\n \": Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn\",\n \"print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]:\",\n \"apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(),\",\n \"If this parameter is equal to 0, an optimised interval will be computed.\",\n \"is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self, val: list,\",\n \"\\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label\",\n \"!= 0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x))\",\n \"like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2\",\n \"as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set\",\n \"= method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must\",\n \"\\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT\",\n \"by: str, optional vColumn to use to partition the data. method: str, optional\",\n \"color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\",\",\n \"method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply(\",\n \"{} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method:\",\n \"vColumn type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory usage\",\n \"= 1 then this method will return the mode of the vColumn. Returns\",\n \"1] ... END odd : CASE ... WHEN vColumn = argv[2 * i]\",\n \"+= \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i -\",\n \"n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\")\",\n \") except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"Returns ------- tablesample An object containing the result. For more information, see utilities.tablesample.\",\n \"return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad'\",\n \"TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice\",\n \"the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ----------\",\n \"assert nb != 0, Exception( \\\"Not enough values to compute the Equal Frequency\",\n \"x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS index, non_events, events, pt_non_events,\",\n \"= \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events =\",\n \"the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"),\",\n \"== \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx:\",\n \"= \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >=\",\n \"/ sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"])\",\n \"\\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except:\",\n \"h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True\",\n \"(method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame\",\n \"---# def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from\",\n \"the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self,\",\n \"\\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\")\",\n \"the floor of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent\",\n \"str = \\\"auto\\\", expr: str = \\\"\\\", by: list = [], order_by: list\",\n \"\\\"The parameter 'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique... depending\",\n \"= \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0\",\n \"--------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn means simply not\",\n \"Vertica’s # speed and built-in analytics and machine learning features. It supports the\",\n \"breaks[idx + 1] if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\",\",\n \"\\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun,\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def\",\n \"Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y,\",\n \"{} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] +=\",\n \"None else \\\"NULL\\\", ) for elem in result if elem[2] != None ]\",\n \"on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"length, unit.upper(), start_or_end ) ) # ---# def spider( self, by: str =\",\n \"dtype : vColumn type iqr : interquartile range kurtosis : kurtosis jb :\",\n \"WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"{} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i],\",\n \"str = \\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\"\",\n \"self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to\",\n \"method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol'\",\n \"instead of moving # data around for processing, VerticaPy brings the logic to\",\n \"# ---# def hist( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"FROM ({}) x ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE\",\n \"aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements to be\",\n \"ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem\",\n \"specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self,\",\n \"The type of pie chart. auto : Regular pie chart. donut : Donut\",\n \"\\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q:\",\n \"following: CENTURY / DAY / DECADE / DOQ / DOW / DOY /\",\n \"datetime from collections.abc import Iterable from typing import Union # VerticaPy Modules import\",\n \"COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY\",\n \"0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can\",\n \"str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will\",\n \": remainder of a division operation pow : number raised to the power\",\n \"GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query,\",\n \"list, optional vColumns used in the partition. return_trans: bool, optimal If set to\",\n \"str / date, optional Input End Date. For example, time = '03-11-1993' will\",\n \"are numerical. Optimized h will be computed if the parameter is empty or\",\n \"except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted\",\n \"catalog will be updated when the parent vDataFrame is modified. Attributes ---------- alias,\",\n \"float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"of the vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also\",\n \"(\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]),\",\n \") cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"vColumns whereas one vColumn can only have one parent. catalog: dict, optional Catalog\",\n \"self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\\\".format(\",\n \"{} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {}\",\n \"skewness # ---# def slice(self, length: int, unit: str = \\\"second\\\", start: bool\",\n \"IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT {}\",\n \") elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"True if the vColumn is numerical, False otherwise. Returns ------- bool True if\",\n \"If set to True, the approximate cardinality is returned. By setting this parameter\",\n \"[(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method ==\",\n \"replace. value: str, optional New value. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] /\",\n \"\\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]),\",\n \"== \\\"minmax\\\": if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\",\",\n \"{} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", )\",\n \"is numerical or of type date like. Optimized h will be computed if\",\n \"{} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({})\",\n \"method = method.lower() if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if\",\n \"float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type\",\n \"(or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"{} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query\",\n \"(\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\",\",\n \"type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS {} FROM\",\n \"vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True,\",\n \"f\\\"A vColumn has already the alias of one of the dummies ({name}).\\\\n\\\" \\\"It\",\n \"an Area Plot. step: bool, optional If set to True, draw a Step\",\n \"AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias,\",\n \"med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans:\",\n \"\\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {},\",\n \"def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements\",\n \"BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\"\",\n \"vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn\",\n \"Forest model parameters used to compute the best splits when 'method' is set\",\n \"an input value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular\",\n \"def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool, optional\",\n \"else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\"\",\n \"= ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], )\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL(\",\n \"= int(total) conj = \\\"s were \\\" if total > 1 else \\\"\",\n \"and 2 bars. It is only valid if the vColumns are numerical. Optimized\",\n \"and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"]\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int,\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a time\",\n \"language governing permissions and # limitations under the License. # # |_ |~)\",\n \"Returns the vColumn DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the\",\n \"[column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0]\",\n \"+ 1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\",\",\n \"------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\",\",\n \"function's performance can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype: str\",\n \"float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] ) if of:\",\n \"percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS\",\n \"interval size to convert to use to convert the vColumn. If this parameter\",\n \"in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches\",\n \"/ / # / / # \\\\ / # \\\\ / # \\\\/\",\n \"scikit-like functionality for conducting # data science projects on data stored in Vertica,\",\n \"categories to [0, n - 1] (n being the vColumn cardinality). Returns -------\",\n \"assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to use a mean\",\n \"---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float\",\n \"5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn\",\n \"str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the\",\n \"NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None\",\n \"vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk\",\n \"next element (Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation).\",\n \": Replaces the outliers by the NULL value. winsorize : Clips the vColumn\",\n \"elements for vColumns 1 and 2 to be used as categorical (No h\",\n \"ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column if the method is\",\n \"Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the\",\n \"quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See\",\n \"PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i )\",\n \"\\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements =\",\n \"] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return\",\n \"optional Number of most occurent elements to return. Returns ------- tablesample An object\",\n \"of a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---#\",\n \"/ **kwargs Any optional parameter to pass to the geopandas plot function. For\",\n \"tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---#\",\n \"= std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store\",\n \"Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to\",\n \"the offset. For example, if n = 1 then this method will return\",\n \"if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = {\",\n \"'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query\",\n \"to solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name\",\n \"self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the top{}\",\n \"if (self.category() == \\\"int\\\") else \\\"\\\" if (h > 1) or (self.category() ==\",\n \"isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method:\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of one of the\",\n \"numerical vColumns, cast the other types to varchar. same_freq : Computes bins with\",\n \"of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\",\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns\",\n \"return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\"\",\n \"kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of\",\n \"nbins will be computed. h: float, optional Interval width of the bar. If\",\n \"when applying the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"',\",\n \"\\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object\",\n \"idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if\",\n \"it. This parameter is very useful for testing to be able to look\",\n \"---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float\",\n \"to draw the Plot. start_date: str / date, optional Input Start Date. For\",\n \"return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna: bool\",\n \"was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{}\",\n \"__ __ __ __ __ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\\",\n \"between the max and the min sem : standard error of the mean\",\n \"(dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*)\",\n \"method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =\",\n \") start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}',\",\n \"= avg # ---# def bar( self, method: str = \\\"density\\\", of: str\",\n \"Draws the histogram of the vColumn based on an aggregation. Parameters ---------- method:\",\n \"numerical, False otherwise. Returns ------- bool True if the vColumn is numerical. See\",\n \"not be considered during the computation. Returns ------- tablesample An object containing the\",\n \"\\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"a limit). Parameters ---------- limit: int, optional Number of elements to display. offset:\",\n \"distinct elements for vColumns 1 and 2 to be used as categorical (No\",\n \"[list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"the parameter 'by' is empty\\\\nIf you want to normalize by grouping by elements,\",\n \"parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent #\",\n \"must be composed of two flower brackets {}. For example to apply the\",\n \"# ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field\",\n \"issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed\",\n \"other statistical information. Parameters ---------- k: int, optional Number of most occurent elements\",\n \"== \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP\",\n \"\\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT\",\n \"else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return\",\n \"store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns -------\",\n \"xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param\",\n \"import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot\",\n \"Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types(\",\n \"an optimized number of bins will be computed. h: float, optional Interval width\",\n \"be composed of two flower brackets {}. For example to apply the function:\",\n \"functions to the input vColumns. vDataFrame.applymap : Applies a function to all the\",\n \"[str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements\",\n \"columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func 'x ->\",\n \"str / date, optional Input Start Date. For example, time = '03-11-1993' will\",\n \"= executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count,\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] #\",\n \") title = \\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias, y)\",\n \"\\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS\",\n \"OF ANY KIND, either express or implied. # See the License for the\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv\",\n \"by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h,\",\n \"= (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\",\",\n \"Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"numerical column for each vColumn category. In this case, the parameter 'numcol' must\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if\",\n \"nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals to 2\",\n \"BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn\",\n \") for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if\",\n \"step: int Size of the slicing. Returns ------- vDataFrame self.parent See Also --------\",\n \"Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate :\",\n \"|______ / / / # |____/ / / # _____________ / / #\",\n \"self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"6, nbins: int = 0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"\\\"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({} / {})\",\n \"corresponding to the offset. For example, if n = 1 then this method\",\n \"[val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val)\",\n \"rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by: str\",\n \"used for the discretization (must be > 1) k: int, optional The integer\",\n \"else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] )\",\n \"the vColumn. Parameters ---------- x: float If the vColumn type is date like\",\n \"method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name,\",\n \"= \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =\",\n \"{} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {} AS\",\n \": Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try:\",\n \"using 'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate :\",\n \"\\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using\",\n \"self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined\",\n \"---------- limit: int, optional Number of elements to display. Returns ------- tablesample An\",\n \"'{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ]\",\n \"Draws the box plot of the vColumn. Parameters ---------- by: str, optional vColumn\",\n \"{} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL(\",\n \"functionality for conducting # data science projects on data stored in Vertica, taking\",\n \"self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using a mean encoding with\",\n \"useful for testing to be able to look at the final transformation. Returns\",\n \"percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS\",\n \"to the power of another number round : rounds a value to a\",\n \"vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE {}\",\n \"= \\\"zscore\\\", by: list = [], return_trans: bool = False ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return\",\n \"== None: warning_message = \\\"The vColumn {} has no mode (only missing values).\\\\nNothing\",\n \"count : Number of elements. density : Percentage of the distribution. mean :\",\n \"--------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ---------- start: int\",\n \"# # Special Methods # # ---# def __init__( self, alias: str, transformations:\",\n \"vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\"\",\n \"binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0,\",\n \": Number of elements. density : Percentage of the distribution. mean : Average\",\n \"in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\":\",\n \"+ [str(count)]) ) query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER\",\n \"for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=\",\n \"as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also\",\n \"\\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem\",\n \"= \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def\",\n \"vDataFrame.isin : Looks if some specific records are in the vDataFrame. \\\"\\\"\\\" if\",\n \") conditions, column = [], self.alias for idx in range(len(breaks) - 1): first_elem,\",\n \"'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the\",\n \"Returns the tail of the vColumn. Parameters ---------- limit: int, optional Number of\",\n \"{} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query,\",\n \"first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r\",\n \"The interval size to convert to use to convert the vColumn. If this\",\n \"value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {},\",\n \": Applies a function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func,\",\n \"Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"result = [self.min()] + result + [self.max()] elif method == \\\"topk\\\": assert k\",\n \"\\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total\",\n \"was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to the vColumn\",\n \"user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The expression generated\",\n \"is used for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers\",\n \"assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must be greater or\",\n \"See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\",\",\n \"LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET\",\n \"dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ----------\",\n \"Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing the\",\n \"n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample\",\n \"dropna: bool = False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth\",\n \"True, the method will return the transformation used instead of the parent vDataFrame.\",\n \"0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0\",\n \"of bins used for the discretization (must be > 1) k: int, optional\",\n \"function to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if\",\n \"the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)\",\n \"nb = int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not enough values\",\n \"aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"- vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\":\",\n \"method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] elif self.isnum() and method\",\n \"are in the vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns\",\n \"\\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] )\",\n \"self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i\",\n \"(vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() ==\",\n \"+ 1 or not (labels), ParameterError( \\\"Length of parameter breaks must be equal\",\n \"Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"or self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\" ) if self.isnum():\",\n \"None else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", ) for elem\",\n \"ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT\",\n \"force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT *\",\n \"its affiliates. # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); #\",\n \"{}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of\",\n \"step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by =\",\n \"or agreed to in writing, software # distributed under the License is distributed\",\n \"{} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self):\",\n \"brings the logic to the data. # # # Modules # # Standard\",\n \"tangent cbrt : cube root ceil : value up to the next whole\",\n \"---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b).\",\n \"the vColumn. If this parameter is equal to 0, an optimised interval will\",\n \"Integer corresponding to the offset. For example, if n = 1 then this\",\n \"this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations],\",\n \"tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format(\",\n \"performance can drastically decrease. Returns ------- float quantile (or approximate quantile). See Also\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn\",\n \"] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"The vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"),\",\n \"vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes\",\n \"0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM\",\n \"vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See Also --------\",\n \"FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"]\",\n \"skewness sum : sum std : standard deviation topk : kth most occurent\",\n \"STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing\",\n \"---# def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of\",\n \"> {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\"\",\n \"around for processing, VerticaPy brings the logic to the data. # # #\",\n \"input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest,\",\n \"'{}' was normalized with the method '{}'.\\\".format( self.alias, method ) ) else: raise\",\n \"number of non-missing elements cvar : conditional value at risk dtype : vColumn\",\n \"{} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL(\",\n \"to 2 in case of discretization using the method 'topk'\\\" ) distinct =\",\n \"'{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\"\",\n \"= quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be\",\n \"is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history:\",\n \"\\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg,\",\n \"\\\"{}\\\" ) ) return self.parent # ---# def fillna( self, val=None, method: str\",\n \"most occurent element percent : percent of non-missing elements q% : q quantile\",\n \"'x' will represent the number of seconds, otherwise it will represent a number.\",\n \") .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3],\",\n \"the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also\",\n \"assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\")\",\n \"the vColumn. method: dict, optional Method to use to impute the missing values.\",\n \"title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin =\",\n \"vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies :\",\n \"a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to impute\",\n \"categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result for item\",\n \"can be 'minute' 'hour'... start: bool, optional If set to True, the record\",\n \"define the outliers. After normalizing the data (Z-Score), if the absolute value of\",\n \"---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is date,\",\n \"Draws the donut chart of the vColumn based on an aggregation. \\\"\\\"\\\" if\",\n \"+ prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") )\",\n \"optional The method used for the plot. gaussian : Gaussian kernel. logistic :\",\n \"than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers\",\n \"result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\"\",\n \"the License. # # |_ |~) _ _| _ /~\\\\ _ |. #\",\n \"def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val\",\n \"\\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\\",\n \"{} WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg\",\n \"copy_trans = [elem for elem in self.transformations] total = self.count() if method not\",\n \"transformed multiple times, so it's better practice to use this method when first\",\n \"self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog\",\n \"---------- x: float Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, )\",\n \"query = \\\"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM\",\n \") ) # ---# def spider( self, by: str = \\\"\\\", method: str\",\n \"{}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{}\",\n \"to False, the function's performance can drastically decrease. Returns ------- int vColumn cardinality\",\n \"> max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations\",\n \"verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---#\",\n \"\\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx\",\n \"copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total > 0: try:\",\n \"\\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was\",\n \"seen as one column of that relation. vColumns simplify several processes with its\",\n \"std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage\",\n \"executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result\",\n \"title=title) # ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \"def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha: float\",\n \"== None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] -\",\n \"|| ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if\",\n \"offset < 0: offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias)\",\n \"histogram of the vColumn based on an aggregation. Parameters ---------- method: str, optional\",\n \"except: model.drop() raise # ---# def describe( self, method: str = \\\"auto\\\", max_cardinality:\",\n \"def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record\",\n \"range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix,\",\n \"float = 0, nbins: int = -1, k: int = 6, new_category: str\",\n \"the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate\",\n \"using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops\",\n \"isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\",\",\n \"a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def\",\n \"setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name]\",\n \"verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL(\",\n \"and self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\")\",\n \"dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn.\",\n \"bool, optional If set to True, the approximate cardinality is returned. By setting\",\n \"int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where =\",\n \"pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"top{} categories of {}.\\\".format( k if k > 0 else \\\"\\\", self.alias ),\",\n \"cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message =\",\n \"{} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" )\",\n \"Returns True if the vColumn category is date. vDataFrame[].isnum : Returns True if\",\n \"\\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\",\",\n \"\\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\\",\n \"record of the vColumn. vDataFrame[].extract : Extracts the regular expression in each record\",\n \"{}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ),\",\n \"is in each of the vColumn records. vDataFrame[].extract : Extracts the regular expression\",\n \"the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\",\",\n \"return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when applying the func\",\n \"tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])])\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx:\",\n \"ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha,\",\n \"column of that relation. vColumns simplify several processes with its abstractions. Parameters ----------\",\n \"elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str =\",\n \"tablesample(values) # ---# def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"\\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds,\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance\",\n \"datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step: bool = False, ax=None,\",\n \"executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def\",\n \"elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations)\",\n \"SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y, query,\",\n \"function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\",\",\n \"(\\\"offset\\\", offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] -\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object Any\",\n \"'Others'. cat_priority: list, optional List of the different categories to consider when drawing\",\n \"xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel,\",\n \"discretize( self, method: str = \\\"auto\\\", h: float = 0, nbins: int =\",\n \"quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\"\",\n \"the vColumn by dropping the current vColumn and creating a copy with the\",\n \"[list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by)\",\n \"to compute the optimal h. auto : Combination of Freedman Diaconis and Sturges.\",\n \"integer k of the 'topk' method. new_category: str, optional The name of the\",\n \"copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def\",\n \"each vColumn category. In this case, the parameter 'numcol' must be defined. numerical\",\n \"columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was\",\n \"for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self,\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---#\",\n \"aggregation. aad : average absolute deviation approx_unique : approximative cardinality count : number\",\n \"is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data\",\n \"result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1]\",\n \"the following: date / int / float / text / binary / spatial\",\n \"ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS\",\n \"\\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize(\",\n \"if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available for\",\n \"be able to look at the final transformation. Returns ------- vDataFrame self.parent See\",\n \"return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function\",\n \"all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x: float\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL(\",\n \"two flower brackets {}. For example to apply the function: x -> x^2\",\n \"Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns -------\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of digits\",\n \"WHEN vColumn = argv[2 * i] THEN argv[2 * i + 1] ...\",\n \"{}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query =\",\n \"if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else:\",\n \"str): order_by = [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\",\",\n \"\\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1)\",\n \"- {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else:\",\n \"verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #\",\n \"to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if\",\n \"if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if\",\n \"), ) else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"if the vColumn is boolean, False otherwise. Returns ------- bool True if the\",\n \"APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format(\",\n \"self.alias), category, ) ) query += [lp + tmp_query + rp] query =\",\n \"in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({},\",\n \"be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum()\",\n \"see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"\\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method\",\n \"(val == None): val = self.mode(dropna=True) if val == None: warning_message = \\\"The\",\n \"next whole number ln : natural logarithm log : logarithm log10 : base\",\n \"(\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean\",\n \"in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else:\",\n \"two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use\",\n \"/ (1.4826 * mad) minmax : Normalization using the MinMax (min and max).\",\n \"------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to use a\",\n \"If set to True, draw a Step Plot. ax: Matplotlib axes object, optional\",\n \"= skewness # ---# def slice(self, length: int, unit: str = \\\"second\\\", start:\",\n \".transpose() .values[self.alias] ) result = [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\",\",\n \"\\\"\\\"\\\" columns = [self.alias] check = True if len(args) > 0: column =\",\n \"self.alias, method ) ) else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\")\",\n \"the most relevant interval to use for the discretization. topk : Keeps the\",\n \"{}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0],\",\n \"of non-Missing elements). Returns ------- int number of non-Missing elements. See Also --------\",\n \"count = self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception(\",\n \"**style_kwds Any optional parameter to pass to the Matplotlib functions. Returns ------- ax\",\n \"Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None, None), ax=None,\",\n \">= 2, ParameterError( \\\"Length of parameter 'breaks' must be greater or equal to\",\n \"vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict :\",\n \"DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result =\",\n \"in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix = (\",\n \"One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a\",\n \"total = int(total) conj = \\\"s were \\\" if total > 1 else\",\n \"warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val\",\n \"names will be generated. include_lowest: bool, optional If set to True, the lowest\",\n \"self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True,\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value\",\n \"\\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1})\",\n \"was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val =\",\n \"GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(),\",\n \"Mode for the categorical vColumns. bfill : Back Propagation of the next element\",\n \"- 1 ) result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using\",\n \"name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for\",\n \"[list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(),\",\n \"Number of bins. If empty, an optimized number of bins will be computed.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur, and\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0]\",\n \"[item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method:\",\n \"or implied. # See the License for the specific language governing permissions and\",\n \"in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14,\",\n \"n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT *\",\n \"offset and a limit). Parameters ---------- limit: int, optional Number of elements to\",\n \"(min and max). (x - min) / (max - min) by: list, optional\",\n \"the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def\",\n \"stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast =\",\n \"will be computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional\",\n \"\\\"NULL\\\", ) for elem in result if elem[1] != None ] ), )\",\n \"f\\\"A vColumn has already the alias {name}.\\\\nBy changing the parameter 'name', you'll be\",\n \"\\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna:\",\n \"/ {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\",\",\n \"See Also -------- vDataFrame.bar : Draws the Bar Chart of the input vColumns\",\n \"if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self,\",\n \"elif h > 0.000001: h = round(h, 6) if self.category() == \\\"int\\\": h\",\n \"Maximum number of vColumn distinct elements to be used as categorical. The less\",\n \"to use to convert the vColumn. If this parameter is equal to 0,\",\n \"Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\"\",\n \"/ int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where = \\\"WHERE\",\n \"mean : Average of the vColumn 'of'. min : Minimum of the vColumn\",\n \"If set to True, the intervals will be closed on the right. Returns\",\n \"if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema\",\n \"if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(),\",\n \": Applies a function to all the vColumns. vDataFrame.eval : Evaluates a customized\",\n \"elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent #\",\n \"elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\"\",\n \"(schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp\",\n \"FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest\",\n \"ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({})\",\n \"query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER\",\n \"- {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\",\",\n \"method 'robust_zscore' is available only if the parameter 'by' is empty\\\\nIf you want\",\n \"a specific TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int,\",\n \"re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass\",\n \"---# def discretize( self, method: str = \\\"auto\\\", h: float = 0, nbins:\",\n \"rule. Parameters ---------- length: int Slice size. unit: str, optional Slice size unit.\",\n \"with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of\",\n \"SQL expression. by: list, optional vColumns used in the partition. order_by: list, optional\",\n \"an advanced analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg\",\n \"APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile =\",\n \"categorical aggregations during the computation. cat_stats : Computes statistics of a numerical column\",\n \"self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast,\",\n \"slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing having steps\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in copy_trans] for elem\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using\",\n \"\\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE\",\n \"WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query)\",\n \"---------- start: int Start of the slicing. step: int Size of the slicing.\",\n \"\\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\")\",\n \"the parameter 'new_name', you'll be able to solve this issue.\\\" ) self.add_copy(new_name) parent\",\n \"kth most occurent element (ex: top1 for the mode) topk_percent : kth most\",\n \"cast the other types to varchar. same_freq : Computes bins with the same\",\n \"_ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / #\",\n \"picked or computed) h: float, optional Interval width of the bar. If empty,\",\n \"str, optional The name of the merging category when using the 'topk' method.\",\n \"self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not enough\",\n \"self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0:\",\n \"Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \\\"\\\"\\\"\",\n \"float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"the Information Value (IV) / Weight Of Evidence (WOE) Table. It tells the\",\n \"the approximate cardinality is returned. By setting this parameter to False, the function's\",\n \"= [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the\",\n \"floor of the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See\",\n \"catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add\",\n \"vDataFrame[].hist : Draws the histogram of the vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"xmin = self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines =\",\n \"parameters used to compute the best splits when 'method' is set to 'smart'.\",\n \"else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", ) for elem in\",\n \"*args / **kwargs Any optional parameter to pass to the geopandas plot function.\",\n \"in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\"\",\n \"+ 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also --------\",\n \"/ int(nbins))) assert nb != 0, Exception( \\\"Not enough values to compute the\",\n \"if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types(\",\n \"Returns True if the vColumn is numerical, False otherwise. Returns ------- bool True\",\n \"type of pie chart. auto : Regular pie chart. donut : Donut chart.\",\n \"the vColumn expected store usage (unit: b). Returns ------- int vColumn expected store\",\n \"is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog\",\n \"[] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else\",\n \"return the mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent\",\n \"if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category())\",\n \"vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes\",\n \"vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority,\",\n \"] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE\",\n \"in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem]\",\n \"input number of digits after the comma. Parameters ---------- n: int Number of\",\n \"if by == []: if fun == \\\"AVG\\\": val = self.avg() elif fun\",\n \"self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ (\",\n \"where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) )\",\n \"Vertica, taking advantage Vertica’s # speed and built-in analytics and machine learning features.\",\n \"unique... depending on the input method. Parameters ---------- method: str, optional The describe\",\n \"check if Badr and Fouad are in the vColumn. You can write the\",\n \"PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9)\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional\",\n \") ] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None:\",\n \"Equal Frequency discretization\\\" ) total, query, nth_elems = nb, [], [] while total\",\n \"See Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap :\",\n \"= executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean). Returns ------- float\",\n \"self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {} named {} was added\",\n \"root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If\",\n \"\\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to\",\n \"------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns\",\n \"self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\",\",\n \"bound to the upper bound itself. Parameters ---------- lower: float, optional Lower bound.\",\n \"aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if\",\n \"Set the x limits of the current axes. ax: Matplotlib axes object, optional\",\n \"), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method\",\n \"self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord,\",\n \"fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0),\",\n \"datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool =\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional\",\n \"\\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ]\",\n \"will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops\",\n \"(SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM\",\n \"\\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem\",\n \"Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {} must be binary\",\n \"greater or equal to 2.\\\" ) assert len(breaks) == len(labels) + 1 or\",\n \"{} AS {}, {} AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias,\",\n \"\\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None)\",\n \"int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors\",\n \"\\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\",\",\n \"the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify\",\n \"float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) /\",\n \"\\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\",\",\n \"0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based\",\n \"END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent #\",\n \"self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None\",\n \"whole number ln : natural logarithm log : logarithm log10 : base 10\",\n \"Version 2.0 (the \\\"License\\\"); # You may not use this file except in\",\n \"name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn\",\n \"self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp\",\n \"\\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing\",\n \"by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the different\",\n \"the vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters\",\n \"BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to\",\n \"-------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"Number of bins used for the discretization (must be > 1) k: int,\",\n \"if the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def\",\n \"object See Also -------- vDataFrame.bar : Draws the Bar Chart of the input\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod\",\n \"of the next element (Constant Interpolation). ffill : Propagation of the first element\",\n \"self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts:\",\n \"an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\",\n \"'numcol' must be defined. numerical : Uses popular numerical aggregations during the computation.\",\n \"+= [lp + tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT *\",\n \"it is used to compute other vColumns. Parameters ---------- add_history: bool, optional If\",\n \"NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title\",\n \"(Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the\",\n \"vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date\",\n \"also increase the time of the learning and scoring phases. xlim: tuple, optional\",\n \"a value to a specified number of decimal places sign : arithmetic sign\",\n \"1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({})\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division by\",\n \"int = -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most\",\n \"---------- val: list List of the different records. For example, to check if\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\",\",\n \"assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of one of\",\n \"(Z-Score), if the absolute value of the record is greater than the threshold,\",\n \"occurent elements and their distributions as percents. Parameters ---------- k: int, optional Number\",\n \"for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"]\",\n \"= 6, h: float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ):\",\n \"- {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev )\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'.\",\n \"if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation = [ ( \\\"({}\",\n \"then 'order_by' must be a list of at least one element to use\",\n \"the Z-Score (avg and std). (x - avg) / std robust_zscore : Normalization\",\n \"input functions. Parameters ---------- func: list List of the different aggregation. aad :\",\n \"1) k: int, optional The integer k of the 'topk' method. new_category: str,\",\n \"occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS\",\n \"\\\"[\\\" if idx == 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif\",\n \"set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame\",\n \"1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION\",\n \"vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes\",\n \"\\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif\",\n \") query += [lp + tmp_query + rp] query = \\\"WITH vdf_table AS\",\n \"threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05, ):\",\n \"== 2, TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) response_cat\",\n \"example: 0.25 represents Q1. approx: bool, optional If set to True, the approximate\",\n \"an aggregation. vColumns will memorize the already computed aggregations to gain in performance.\",\n \"{}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {},\",\n \"self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"== \\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\" for i in\",\n \"outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled.\",\n \"ParameterError( \\\"Parameter 'response' can not be empty in case of discretization using the\",\n \"return. dropna: bool, optional If set to True, NULL values will not be\",\n \"the vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate :\",\n \"creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of\",\n \"optional Number of elements to display. Returns ------- tablesample An object containing the\",\n \"nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset:\",\n \"FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL\",\n \"return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---#\",\n \"result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min,\",\n \"performance can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate :\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut\",\n \"search. See Also -------- vDataFrame.isin : Looks if some specific records are in\",\n \") response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {}\",\n \"def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the\",\n \"if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of\",\n \"--------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur, and other\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def\",\n \"optional If not empty, a copy will be created using the input Name.\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int,\",\n \"\\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ]\",\n \"the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result\",\n \"float / text / binary / spatial / uuid / undefined Returns -------\",\n \"logic to the data. # # # Modules # # Standard Python Modules\",\n \"int, optional Maximum number of nbins used for the discretization (must be >\",\n \"the other into one unique category. h: float, optional The interval size to\",\n \"vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold'\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---#\",\n \"\\\"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"',\",\n \"expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name,\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned\",\n \"quantile. For example: 0.25 represents Q1. approx: bool, optional If set to True,\",\n \"self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as e: raise\",\n \"drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame.\",\n \"\\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE\",\n \"{} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int,\",\n \"optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the first dummy\",\n \"[elem for elem in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {},\",\n \"0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS\",\n \"\\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn\",\n \"(Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"# ---# def slice(self, length: int, unit: str = \\\"second\\\", start: bool =\",\n \"- pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER\",\n \"= [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return\",\n \"self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({}) THEN {} || ''\",\n \"k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = (\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n: int, optional\",\n \"as categorical. The less frequent elements will be gathered together to create a\",\n \"self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0]\",\n \"self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100\",\n \"amount of expressions. The expression generated will look like: even: CASE ... WHEN\",\n \"not normalize {} using a Z-Score - The Standard Deviation is null !\\\".format(\",\n \"= \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\"\",\n \"---------- method: str, optional Method to use to fill the vColumn outliers. mean\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\",\",\n \"self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import\",\n \"return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self,\",\n \"List of the different transformations. \\\"\\\"\\\" # # Special Methods # # ---#\",\n \"{}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"[elem for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return\",\n \"x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an\",\n \"the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({},\",\n \"missing elements in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str,\",\n \"result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method\",\n \"i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None\",\n \"def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn.\",\n \"discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name)\",\n \"def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function\",\n \"The vColumn {} was converted to {}.\\\".format( self.alias, dtype ) ) return self.parent\",\n \"of the vColumn. Parameters ---------- limit: int, optional Number of elements to display.\",\n \"{} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(),\",\n \"{}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode\",\n \"AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"(x - avg) / std robust_zscore : Normalization using the Robust Z-Score (median\",\n \"_verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY {}\",\n \"{new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to solve this issue.\\\" )\",\n \"{}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias,\",\n \"= '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx),\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws\",\n \"= \\\"Can not normalize {} using a Z-Score - The Standard Deviation is\",\n \"\\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self,\",\n \"equal to 1\\\") where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if\",\n \"\\\"The method 'robust_zscore' is available only if the parameter 'by' is empty\\\\nIf you\",\n \"bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper\",\n \"sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, )\",\n \"is boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn category\",\n \"\\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available\",\n \"True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") #\",\n \"in compliance with the License. # You may obtain a copy of the\",\n \"by an input value. The vColumn will be transformed. Parameters ---------- to_replace: str\",\n \"Interval width of the bar. If empty, an optimized h will be computed.\",\n \"License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or\",\n \"def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent\",\n \"to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) +\",\n \"[ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ),\",\n \"\\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\"\",\n \"this parameter to False, the function's performance can drastically decrease. Returns ------- float\",\n \"empty, a copy will be created using the input Name. Returns ------- vDataFrame\",\n \"query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\",\",\n \"{})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\",\",\n \"BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing\",\n \"A float between 0 and 1 that represents the quantile. For example: 0.25\",\n \"[int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x:\",\n \"on numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of\",\n \"self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---#\",\n \"{}.\\\".format( k if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values\",\n \"int, optional Integer corresponding to the offset. For example, if n = 1\",\n \"True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs)\",\n \"iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value\",\n \"sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in elem: if\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self,\",\n \"= {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])]\",\n \"use to determine if the vColumn will be considered as categorical. numcol: str,\",\n \"= \\\"Can not normalize {} using the MIN and the MAX. MAX =\",\n \"else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in\",\n \"k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)]\",\n \"Start Date. For example, time = '03-11-1993' will filter the data when 'ts'\",\n \"the average of the response partitioned by the different vColumn categories. Parameters ----------\",\n \"the number of seconds, otherwise it will represent a number. Returns ------- vDataFrame\",\n \"(use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\",\",\n \"and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError(\",\n \"warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try:\",\n \"n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax\",\n \"of matches for the regular expression in each record of the vColumn. vDataFrame[].extract\",\n \"--------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str, Function in\",\n \"\\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower()\",\n \"or one of its affiliates. # Licensed under the Apache License, Version 2.0\",\n \"element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\",\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv:\",\n \"upper, [float, int])]) assert (lower != None) or (upper != None), ParameterError( \\\"At\",\n \"1) or (self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {})\",\n \"\\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by'\",\n \"The name of the merging category when using the 'topk' method. RFmodel_params: dict,\",\n \"by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k\",\n \"\\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query\",\n \"self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {} FROM (SELECT {}\",\n \"\\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), )\",\n \"[(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label\",\n \": Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response\",\n \"= ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr\",\n \"categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return\",\n \"str, optional The method used for the plot. gaussian : Gaussian kernel. logistic\",\n \"self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item in result],\",\n \"the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7],\",\n \"# |_ |~) _ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_|||\",\n \"result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result =\",\n \"Label Encoding was applied to the vColumn {} using the following mapping:{}\\\".format( self.alias,\",\n \"\\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str):\",\n \"return self elif n == 1: try: result = executeSQL( \\\"SELECT {}, MIN({}),\",\n \"'same_width' for numerical vColumns, cast the other types to varchar. same_freq : Computes\",\n \"threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05 ):\",\n \"== \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN\",\n \"Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k\",\n \"] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical /\",\n \"else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False,\",\n \"'labels' + 1 or parameter 'labels' must be empty.\\\" ) conditions, column =\",\n \"= True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers\",\n \"will be included. right: bool, optional How the intervals should be closed. If\",\n \"distributions as percents. Parameters ---------- k: int, optional Number of most occurent elements\",\n \"optional If set to True, the approximate median is returned. By setting this\",\n \"(1.4826 * mad) minmax : Normalization using the MinMax (min and max). (x\",\n \"columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx %\",\n \"{}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] !=\",\n \"skip. Returns ------- tablesample An object containing the result. For more information, see\",\n \"to use to impute the vColumn. method: dict, optional Method to use to\",\n \"---# def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \") ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema =\",\n \"RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used to compute\",\n \"set to True, the information will be stored in the vDataFrame history. Returns\",\n \"str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ----------\",\n \"\\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method 'robust_zscore' is available only\",\n \"The vColumn type must be date like (date, datetime, timestamp...) or numerical. q:\",\n \"{} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1)\",\n \"\\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in\",\n \"= self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0],\",\n \"self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---#\",\n \"= len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels,\",\n \"def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of mean).\",\n \"check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold,\",\n \"new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean =\",\n \"Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val !=\",\n \"the vColumn using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate\",\n \"category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try:\",\n \"from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]),\",\n \"Parameters ---------- k: int, optional Number of most occurent elements to return. Returns\",\n \"\\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\",\",\n \"(IV) / Weight Of Evidence (WOE) Table. It tells the predictive power of\",\n \"import * from verticapy.toolbox import * from verticapy.errors import * ## # #\",\n \"New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the\",\n \"\\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method == \\\"categorical\\\"))\",\n \"of discretization using the method 'same_freq'\\\" ) count = self.count() nb = int(float(count\",\n \"gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins'\",\n \"vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent\",\n \"distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT\",\n \"self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold )\",\n \"Also -------- vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS\",\n \"processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional\",\n \"using previously the method on the vColumn \\\" \\\"or simply because of ambiguous\",\n \"number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \"Also -------- vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws\",\n \"RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else:\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global\",\n \"2) + 2\\\". copy_name: str, optional If not empty, a copy will be\",\n \"(\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\"\",\n \"> max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*)\",\n \"for sublist in query_result for item in sublist] # ---# def div(self, x:\",\n \"\\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\":\",\n \"self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING\",\n \"bool = True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns\",\n \"Parameters ---------- argv: object Any amount of expressions. The expression generated will look\",\n \"Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\")\",\n \"ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---# def describe(\",\n \"---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn\",\n \"of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode\",\n \"), ) if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\"\",\n \"do not apply it. This parameter is very useful for testing to be\",\n \"-------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB type.\",\n \"optional The method to use to discretize the vColumn. auto : Uses method\",\n \"(dropna): n = \\\"\\\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal):\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers.\",\n \"The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if some\",\n \"y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV)\",\n \"= product # ---# def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\"\",\n \": Maximum of the vColumn 'of'. sum : Sum of the vColumn 'of'.\",\n \"the next element (Constant Interpolation). ffill : Propagation of the first element (Constant\",\n \"a user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The expression\",\n \"area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by:\",\n \"self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut,\",\n \"numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality +\",\n \"(FLOOR({} / {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\",\",\n \"vColumn will be considered as categorical. numcol: str, optional Numerical vColumn to use\",\n \"[str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace:\",\n \"partition the data. bandwidth: float, optional The bandwidth of the kernel. kernel: str,\",\n \"= 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they\",\n \"approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'.\",\n \"n: int, optional Offset. Returns ------- tablesample An object containing the result. For\",\n \"vColumn. transformations, str : List of the different transformations. \\\"\\\"\\\" # # Special\",\n \"expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype:\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x\",\n \"self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype),\",\n \"dict, optional Dictionary of the Random Forest model parameters used to compute the\",\n \"of the vColumn distinct elements to be used as categorical (No h will\",\n \"lower outliers by their respective average. null : Replaces the outliers by the\",\n \"result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP\",\n \"{} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return\",\n \"func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS\",\n \"the same number of elements. same_width : Computes regular width bins. smart :\",\n \") for elem in result if elem[1] != None ] ), ) cmax\",\n \"new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and\",\n \"\\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date)\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression in\",\n \"vColumn using a bijection from the different categories to [0, n - 1]\",\n \"if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column =\",\n \"!= None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater\",\n \"list will be included. right: bool, optional How the intervals should be closed.\",\n \"the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias:\",\n \"else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1])\",\n \"loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements. Parameters ---------- n:\",\n \"Verifies if the regular expression is in each of the vColumn records. vDataFrame[].extract\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/\",\n \"{}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, )\",\n \") ) # ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices\",\n \"(is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index =\",\n \"vColumn = argv[2 * i] THEN argv[2 * i + 1] ... END\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by:\",\n \"x, [int, float])]) assert x != 0, ValueError(\\\"Division by 0 is forbidden !\\\")\",\n \"(sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\":\",\n \"\\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\",\",\n \"*args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn and\",\n \"1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool,\",\n \"to be able to look at the final transformation. Returns ------- vDataFrame self.parent\",\n \"vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func:\",\n \"IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {} AS {},\",\n \": Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\",\",\n \"in case of discretization using the method 'same_freq'\\\" ) count = self.count() nb\",\n \"to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical : Uses\",\n \"deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold:\",\n \"kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors\",\n \"*= 1.4826 if mad != 0: if return_trans: return \\\"({} - {}) /\",\n \"= self.max() else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct()\",\n \"int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often\",\n \"(\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert (method != \\\"cat_stats\\\") or\",\n \"self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM\",\n \"# ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute\",\n \"'ts' is lesser than November 1993 the 3rd. end_date: str / date, optional\",\n \"1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({})\",\n \"ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset: int =\",\n \"\\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1],\",\n \"lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None) or (upper\",\n \"Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts,\",\n \"---# def normalize( self, method: str = \\\"zscore\\\", by: list = [], return_trans:\",\n \"optional If set to True, the lowest element of the list will be\",\n \"store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage.\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format(\",\n \"\\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ): n = len(result) trans\",\n \"check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs):\",\n \"and their distributions as percents. Parameters ---------- k: int, optional Number of most\",\n \"column = kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column)\",\n \"an optimized h will be computed. ax: Matplotlib axes object, optional The axes\",\n \"if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM\",\n \"DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(),\",\n \"_verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the\",\n \"int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not enough values to compute\",\n \"self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\":\",\n \"(\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"create a new category : 'Others'. cat_priority: list, optional List of the different\",\n \"{}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias,\",\n \"] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias, dtype )\",\n \"[], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx\",\n \"{} was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self, n:\",\n \"(\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float,\",\n \"== 1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format(\",\n \"computed aggregations to gain in performance. The catalog will be updated when the\",\n \"use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for\",\n \"One vDataFrame can have multiple children vColumns whereas one vColumn can only have\",\n \"based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"upper bound quantile(1-alpha) if 'use_threshold' is set to False else the lower and\",\n \"{}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_\",\n \"avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not\",\n \"* sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was\",\n \"result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias,\",\n \"of the vColumn. transformations, str : List of the different transformations. \\\"\\\"\\\" #\",\n \"'{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func:\",\n \") warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() < 50):\",\n \"= self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name,\",\n \"= 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold:\",\n \"the topk most frequent categories and merge the other into one unique category.\",\n \"and creating a copy with the specified name. \\\\u26A0 Warning : SQL code\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply(\",\n \"NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(),\",\n \"the vColumn records. The vColumn will be transformed. Parameters ---------- pat: str Regular\",\n \"/ # \\\\ / # \\\\/ # _ # \\\\ / _ __|_.\",\n \"self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {},\",\n \"not (labels), ParameterError( \\\"Length of parameter breaks must be equal to the length\",\n \"category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the\",\n \"raise QueryError( \\\"{}\\\\nError when applying the func 'x -> {}' to '{}'\\\".format( e,\",\n \"(No h will be picked or computed) h: float, optional Interval width of\",\n \"(\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int,\",\n \"encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = (\",\n \"not selecting it in the final generated SQL code. Note: Dropping a vColumn\",\n \"numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must\",\n \"use to normalize. zscore : Normalization using the Z-Score (avg and std). (x\",\n \"query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION\",\n \"different categories to [0, n - 1] (n being the vColumn cardinality). Returns\",\n \"= 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol,\",\n \"---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user transformations.\",\n \"avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix\",\n \"parameter is very useful for testing to be able to look at the\",\n \"vColumn can make the vDataFrame \\\"heavier\\\" if it is used to compute other\",\n \"value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements,\",\n \"type is date like). The vColumn will be transformed. Parameters ---------- field: str\",\n \"of elements. same_width : Computes regular width bins. smart : Uses the Random\",\n \"category, ) ) query += [lp + tmp_query + rp] query = \\\"WITH\",\n \"to transform the vColumn. abs : absolute value acos : trigonometric inverse cosine\",\n \"= executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method ==\",\n \"k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)]\",\n \"vColumn to the input type. Parameters ---------- dtype: str New type. Returns -------\",\n \"[int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must\",\n \"quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]),\",\n \"{} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {}\",\n \") func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent #\",\n \"\\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\" )\",\n \"vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True if the\",\n \"RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name,\",\n \"), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__()\",\n \"bool, optimal If set to True, the method will return the transformation used\",\n \"vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if some specific\",\n \"\\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"binary / spatial / uuid / undefined Returns ------- str vColumn category. See\",\n \"def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str\",\n \"new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\",\",\n \"- alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha,\",\n \"[CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method,\",\n \"one of its affiliates. # Licensed under the Apache License, Version 2.0 (the\",\n \"AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE\",\n \": Returns the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---#\",\n \"float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr =\",\n \"vColumn {} can not be converted to {}\\\".format( e, self.alias, dtype ) )\",\n \"self.alias, \\\", \\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION\",\n \"- {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self,\",\n \"Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if it is used to\",\n \"return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list = [],\",\n \"If set to True, draw an Area Plot. step: bool, optional If set\",\n \"optional Slice size unit. For example, it can be 'minute' 'hour'... start: bool,\",\n \"dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and\",\n \"{} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha =\",\n \"NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias),\",\n \"{}, response: str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes\",\n \"distinct elements to be used as categorical. The less frequent elements will be\",\n \"= 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method.\",\n \"be computed. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"{}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {},\",\n \"vColumn (only if the vColumn type is date like). The vColumn will be\",\n \"sublist in query_result for item in sublist] # ---# def div(self, x: float):\",\n \"---# def iloc(self, limit: int = 5, offset: int = 0): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn {} using the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent #\",\n \"__ `\\\\ / / # | \\\\/ / / / # |______ /\",\n \"= \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, h: float =\",\n \"n == 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev\",\n \"must be date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn\",\n \"least 'lower' or 'upper' must have a numerical value\\\" ) lower_when = (\",\n \"\\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"\\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n > 0: warning_message\",\n \"Date. For example, time = '03-11-1993' will filter the data when 'ts' is\",\n \"assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical / date-like vColumns.\\\"\",\n \"str, optional SQL expression. by: list, optional vColumns used in the partition. order_by:\",\n \"[int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert (method !=\",\n \"< 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop\",\n \"Plot. Parameters ---------- by: str, optional vColumn to use to partition the data.\",\n \"categorical (No h will be picked or computed) h: float, optional Interval width\",\n \"Returns a part of the vColumn (delimited by an offset and a limit).\",\n \"), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin\",\n \") self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier,\",\n \"== \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or\",\n \"True if pie_type == \\\"donut\\\" else False rose = True if pie_type ==\",\n \"different than 1.\\\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start,\",\n \"1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple = None,\",\n \"input method. Parameters ---------- method: str, optional Method to use to fill the\",\n \"(\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float,\",\n \"of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str :\",\n \"and lower outliers by their respective average. null : Replaces the outliers by\",\n \"method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result\",\n \"else \\\"\\\", cmax, cmin, ) else: final_transformation = [ ( \\\"({} - {})\",\n \"as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, )\",\n \"new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of\",\n \"of the vColumn 'of' (ex: 50% to get the median). It can also\",\n \"Parameters ---------- method: str, optional Method to use to normalize. zscore : Normalization\",\n \"(Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"'{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent,\",\n \"trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS\",\n \"] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return\",\n \"average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input\",\n \"alias, str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent,\",\n \"'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value\",\n \"for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None)\",\n \"to the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info ) ) return\",\n \"ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total =\",\n \"column in by]) ) if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column)\",\n \"if the vColumn category is date, False otherwise. Returns ------- bool True if\",\n \"data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent #\",\n \"Prefix delimitor of the dummies. drop_first: bool, optional Drops the first dummy to\",\n \"step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series\",\n \"True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ----------\",\n \"bar width. Parameters ---------- method: str, optional Method to use to compute the\",\n \"a bijection from the different categories to [0, n - 1] (n being\",\n \"regular expression is in each of the vColumn records. The vColumn will be\",\n \"the vColumn using multiple statistical aggregations: min, max, median, unique... depending on the\",\n \"# \\\\ / / / # \\\\/ / / # / / #\",\n \"for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid :\",\n \"= ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if\",\n \"vColumn = argv[2 * i] THEN argv[2 * i + 1] ... ELSE\",\n \"and 2 to be used as categorical (No h will be picked or\",\n \"normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"For example: 0.25 represents Q1. approx: bool, optional If set to True, the\",\n \"/ text / binary / spatial / uuid / undefined Returns ------- str\",\n \"records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)):\",\n \"vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of\",\n \"the Apache License, Version 2.0 (the \\\"License\\\"); # You may not use this\",\n \"mode : most occurent element percent : percent of non-missing elements q% :\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions\",\n \": standard deviation topk : kth most occurent element (ex: top1 for the\",\n \"vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn can only\",\n \"int, optional Offset. Returns ------- tablesample An object containing the result. For more\",\n \"method: str, optional The method to use to aggregate the data. count :\",\n \"return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on type\",\n \"catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1,\",\n \"abs(self.count() - total) except Exception as e: self.transformations = [elem for elem in\",\n \"'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and\",\n \"to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\",\",\n \"length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end =\",\n \"______ ______ __ __ __ __ __ __ __ # /\\\\ \\\\ /\",\n \": Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn\",\n \"one of the following: CENTURY / DAY / DECADE / DOQ / DOW\",\n \"{}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different\",\n \"-------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns\",\n \"} if ((is_date) and not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\"\",\n \"the vColumn 'of'. min : Minimum of the vColumn 'of'. max : Maximum\",\n \": Slices the vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field,\",\n \"(Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"computed) ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"elem[1] if elem[1] != None else \\\"NULL\\\", ) for elem in result if\",\n \"for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations +=\",\n \"Error happened during the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in\",\n \"data. bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional The\",\n \"applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) )\",\n \"int, optional Cardinality threshold to use to determine if the vColumn will be\",\n \"ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates\",\n \"# ---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific\",\n \"\\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i] ) trans +=\",\n \"aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use to determine\",\n \"{}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query\",\n \"the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical.\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def\",\n \"self.alias, n ) title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query,\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response)\",\n \"by their respective average. null : Replaces the outliers by the NULL value.\",\n \"({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"the intervals should be closed. If set to True, the intervals will be\",\n \"the Plot. start_date: str / date, optional Input Start Date. For example, time\",\n \"= \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"slicing having steps different than 1.\\\" ) index_stop = index.stop index_start = index.start\",\n \"method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not be empty in\",\n \"in query_result for item in sublist] # ---# def div(self, x: float): \\\"\\\"\\\"\",\n \"during the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"]\",\n \"if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop:\",\n \"/\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\\",\n \"be computed. h: float, optional Interval width of the bar. If empty, an\",\n \"Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority,\",\n \"datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False,\",\n \"product range : difference between the max and the min sem : standard\",\n \"the data. h: float, optional Interval width if the vColumn is numerical or\",\n \"a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"',\",\n \"no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent\",\n \"'\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not\",\n \"2.\\\" ) assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \\\"Length\",\n \"Aggregates the vColumn using 'sem' (standard error of mean). Returns ------- float sem\",\n \"are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val\",\n \"ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias,\",\n \"datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts =\",\n \"\\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts\",\n \"must be similar to the following: (function, type, category) parent: vDataFrame, optional Parent\",\n \"\\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200,\",\n \"were \\\" if total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{}\",\n \"as categorical (No h will be picked or computed) h: float, optional Interval\",\n \"result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0],\",\n \"if some specific records are in the vColumn and it returns the new\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method\",\n \"ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart\",\n \"/ / # \\\\ / / / # \\\\/ / / # /\",\n \"Number of elements to skip. Returns ------- tablesample An object containing the result.\",\n \"type must be date like (date, datetime, timestamp...) or numerical. by: str, optional\",\n \"(\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for\",\n \"Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\",\",\n \"\\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns = [ column for\",\n \"fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert\",\n \"(nullifzero) else \\\"\\\", stddev ) else: final_transformation = [ ( \\\"({} - {})\",\n \"date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to use\",\n \"), (\\\"x\\\", x, [int, float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\",\",\n \"Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] ==\",\n \"If the vDataFrame represents the entire relation, a vColumn can be seen as\",\n \"of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"aggregations: min, max, median, unique... depending on the input method. Parameters ---------- method:\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad\",\n \"), ) if return_trans: return \\\"({} - {}) / {}({} - {})\\\".format( self.alias,\",\n \"int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func)\",\n \"i] THEN argv[2 * i + 1] ... END odd : CASE ...\",\n \"records. vDataFrame[].extract : Extracts the regular expression in each record of the vColumn.\",\n \"(nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\":\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels:\",\n \"< 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <=\",\n \"Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode\",\n \"/ 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar\",\n \"self.alias, name ) ) return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\"\",\n \"x)) # ---# def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the\",\n \"\\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0]\",\n \"kurtosis jb : Jarque-Bera index mad : median absolute deviation max : maximum\",\n \"[int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] ) if\",\n \"return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot(\",\n \"vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) )\",\n \"self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM\",\n \"(\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if (start)\",\n \"expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [\",\n \"\\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor\",\n \"float = 4.0, use_threshold: bool = True, alpha: float = 0.05 ): \\\"\\\"\\\"\",\n \"you want to normalize by grouping by elements, please use a method in\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ----------\",\n \"str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in\",\n \"See Also -------- vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\" check_types(\",\n \"\\\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format(\",\n \"non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS\",\n \"\\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum()\",\n \"def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns\",\n \"= gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter\",\n \"if the absolute value of the record is greater than the threshold it\",\n \"elements to be used as categorical (No h will be picked or computed)\",\n \"\\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\",\",\n \"rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn\",\n \"Labels used to name the new categories. If empty, names will be generated.\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}',\",\n \"(\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only works\",\n \"elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] -\",\n \"FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev = (\",\n \"start, [bool]), ] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply(\",\n \"decrease. Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate :\",\n \"of the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also\",\n \"using the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply :\",\n \"---# def median( self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters\",\n \"solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses\",\n \"avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value:\",\n \"\\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def\",\n \") # ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the\",\n \"otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats : Computes\",\n \"optional SQL expression. by: list, optional vColumns used in the partition. order_by: list,\",\n \"the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func\",\n \"expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method\",\n \"field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only\",\n \"== \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] )\",\n \"return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn\",\n \"\\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\":\",\n \"check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right,\",\n \"is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\"\",\n \"value: str, optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also --------\",\n \"sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name:\",\n \"method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn\",\n \"self.isnum(): if method == \\\"zscore\\\": if n == 0: nullifzero = 0 avg,\",\n \"--------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func: str Function\",\n \"of nbins will be computed. h: float, optional Interval width of the bar.\",\n \"self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return\",\n \"LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols,\",\n \"* sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) /\",\n \"relation to the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int,\",\n \"Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate\",\n \"will be computed. ax: Matplotlib axes object, optional The axes to plot on.\",\n \"max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations\",\n \"date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean.\",\n \"(\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\")\",\n \"return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr,\",\n \"the method to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical\",\n \"[(new_column, ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result\",\n \"if the parameter 'by' is empty\\\\nIf you want to normalize by grouping by\",\n \"chart. auto : Regular pie chart. donut : Donut chart. rose : Rose\",\n \"percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \": Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True if\",\n \"title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result) else result[0][0]\",\n \"0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] =\",\n \"self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count,\",\n \"result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 -\",\n \"= 4.0, use_threshold: bool = True, alpha: float = 0.05, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column =\",\n \"max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool = True): \\\"\\\"\\\"\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See Also\",\n \"categorical vColumns. bfill : Back Propagation of the next element (Constant Interpolation). ffill\",\n \"\\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index < 0: index +=\",\n \"return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool = True):\",\n \"0: warning_message = \\\"The method 'robust_zscore' is available only if the parameter 'by'\",\n \"expression matches in each of the vColumn record by an input value. The\",\n \"\\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS {} FROM {}\",\n \"or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in\",\n \"using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN\",\n \"the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix\",\n \"= {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for item in\",\n \"(n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\":\",\n \"executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\":\",\n \"if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor\",\n \"# / # ____________ ______ # / __ `\\\\ / / # |\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] ) if by:\",\n \"\\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start: int,\",\n \"self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations\",\n \"'method' is set to 'smart'. A RF Regressor will be trained if the\",\n \"regular expression matches in each of the vColumn records by an input value.\",\n \"order the data. The vColumn type must be date like (date, datetime, timestamp...)\",\n \"self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding.\",\n \"h > 0.01: h = round(h, 2) elif h > 0.0001: h =\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x))\",\n \"vColumns using the input method. Parameters ---------- method: str, optional Method to use\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis\",\n \"approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"title=\\\"Computing the average of the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\",\",\n \"is part of the DB version you are using. Returns ------- tablesample An\",\n \"cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message = \\\"Can\",\n \"\\\"int\\\") else \\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"): trans =\",\n \"---# def slice(self, length: int, unit: str = \\\"second\\\", start: bool = True):\",\n \"Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in each of\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality,\",\n \"val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\", by: list = [],\",\n \"1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning)\",\n \"= \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if len(cat)\",\n \"**style_kwds) # ---# def iloc(self, limit: int = 5, offset: int = 0):\",\n \"of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes the\",\n \"] if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index,\",\n \"0 for column in all_cols: try: if (quote_ident(column) in func) or ( re.search(\",\n \"{}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0],\",\n \"the vColumn. Parameters ---------- by: str, optional vColumn to use to partition the\",\n \"LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title,\",\n \"See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by,\",\n \"elements, how often they occur, and other statistical information. Parameters ---------- k: int,\",\n \"to True, the approximate cardinality is returned. By setting this parameter to False,\",\n \"add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping\",\n \": Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int,\",\n \"IN ({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [\",\n \"the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements to\",\n \"import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#\",\n \"Slice size. unit: str, optional Slice size unit. For example, it can be\",\n \"division operation pow : number raised to the power of another number round\",\n \"return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int = 5):\",\n \"return self.parent # ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"axes object \\\"\\\"\\\" columns = [self.alias] check = True if len(args) > 0:\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"= [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\",\",\n \"(\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] )\",\n \"result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha],\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] #\",\n \") else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias]\",\n \"self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat:\",\n \"2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins\",\n \"[ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ]\",\n \"exp : exponential function floor : value down to the next whole number\",\n \"range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE\",\n \"self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\"\",\n \"\\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if\",\n \"0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS\",\n \"drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the\",\n \"encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor):\",\n \"modified. Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog of\",\n \"1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")]\",\n \"vDataFrame[].bar : Draws the Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\"\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns ------- bool\",\n \"the Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not\",\n \"AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias),\",\n \"def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will\",\n \"limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn.\",\n \"to order the data. The vColumn type must be date like (date, datetime,\",\n \"usage (unit: b). Returns ------- int vColumn expected store usage. See Also --------\",\n \"+ 5). ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", )\",\n \"1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias,\",\n \"series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str,\",\n \"method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif method == \\\"topk\\\": assert\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {} WHERE\",\n \"using 'mad' (median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate\",\n \"object See Also -------- vDataFrame.donut : Draws the donut chart of the vColumn\",\n \"numerical. by: str, optional vColumn to use to partition the TS. start_date: str\",\n \"cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\",\",\n \"# \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\\",\n \"---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only\",\n \"-> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---#\",\n \"+= [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self,\",\n \"of {}.\\\".format( k if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", )\",\n \"elements q% : q quantile (ex: 50% for the median) prod : product\",\n \"# # Unless required by applicable law or agreed to in writing, software\",\n \"float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"True if the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn\",\n \"1.\\\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start\",\n \"compute the optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis\",\n \"of another number round : rounds a value to a specified number of\",\n \"auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2\",\n \"threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns\",\n \"either express or implied. # See the License for the specific language governing\",\n \"the new categories. If empty, names will be generated. include_lowest: bool, optional If\",\n \"kwargs: query = \\\"SELECT {} AS {} FROM {} WHERE {} IS NOT\",\n \"the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes\",\n \"processing, VerticaPy brings the logic to the data. # # # Modules #\",\n \"self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must\",\n \"{} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({})\",\n \"float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, )\",\n \"\\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---#\",\n \"right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2,\",\n \") ) # ---# def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\"\",\n \"{}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if (by) else \\\"\\\" )\",\n \"+= [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {} named {}\",\n \"= RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params)\",\n \"in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value\",\n \"= (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str\",\n \"self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized\",\n \"int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed.\",\n \"outliers. mean : Replaces the upper and lower outliers by their respective average.\",\n \"IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str =\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also --------\",\n \"\\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = (\",\n \"): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in transformations],\",\n \"optional Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns\",\n \"self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({}\",\n \"5). of: str, optional The vColumn to use to compute the aggregation. max_cardinality:\",\n \"# ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns\",\n \"\\\"[Get Dummies]: One hot encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format(\",\n \"instead of the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold.\",\n \"] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by\",\n \"NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype =\",\n \") ] if method != \\\"robust_zscore\\\": max_floor = 0 for elem in by:\",\n \"method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0]\",\n \"else: limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format(\",\n \"len(labels) + 1 or not (labels), ParameterError( \\\"Length of parameter breaks must be\",\n \"the License. # You may obtain a copy of the License at #\",\n \"/ 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif\",\n \"if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\",\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"])\",\n \"= max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool = True):\",\n \"(ex: AVG(column1) + 5). of: str, optional The vColumn to use to compute\",\n \"(lower != None) or (upper != None), ParameterError( \\\"At least 'lower' or 'upper'\",\n \"h > 0.000001: h = round(h, 6) if self.category() == \\\"int\\\": h =\",\n \"bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method.\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool\",\n \"{}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self,\",\n \"= self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors()\",\n \"method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha ==\",\n \"= self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"--------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used are the\",\n \"def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum\",\n \") ) else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations\",\n \"argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a\",\n \"name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax,\",\n \"Method to use to normalize. zscore : Normalization using the Z-Score (avg and\",\n \"the regular expression matches in each of the vColumn record by an input\",\n \"\\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements.\",\n \"WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias,\",\n \"Any optional parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self,\",\n \"\\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1,\",\n \"(self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing the parameter 'name',\",\n \"int Number of digits to keep after the comma. Returns ------- vDataFrame self.parent\",\n \"= None if not (result) else result[0][0] if not (dropna): n = \\\"\\\"\",\n \"i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---#\",\n \"dtype: str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype :\",\n \"-------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types( [\",\n \"AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, )\",\n \"str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ (\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the\",\n \"0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"',\",\n \"\\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def\",\n \") assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of one\",\n \"some specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not\",\n \"6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"key corresponds to an aggregation. vColumns will memorize the already computed aggregations to\",\n \"label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column}\",\n \"\\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____\",\n \"( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") +\",\n \": Returns True if the vColumn category is date. \\\"\\\"\\\" return self.category() in\",\n \"Other aggregations could work if it is part of the DB version you\",\n \"( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ]\",\n \"Robust Z-Score - The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({}\",\n \") method = method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if\",\n \"( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] -\",\n \"\\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values\",\n \"elements to return. Returns ------- tablesample An object containing the result. For more\",\n \"if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\":\",\n \"query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start,\",\n \"\\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol\",\n \"(delimited by an offset and a limit). Parameters ---------- limit: int, optional Number\",\n \"n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query =\",\n \"(self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {}\",\n \"try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = (\",\n \"seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent See Also\",\n \"{} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func =\",\n \"by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem\",\n \"of the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"__|_. _ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/ # / #\",\n \"LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias]\",\n \"OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query =\",\n \"new vColumn labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if\",\n \"be considered during the computation. n: int, optional Integer corresponding to the offset.\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority,\",\n \": vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame :\",\n \"LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts )\",\n \"--------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on an aggregation.\",\n \"each of the vColumn record by an input value. The vColumn will be\",\n \"will be picked or computed) ax: Matplotlib axes object, optional The axes to\",\n \"-------- vDataFrame[].tail : Returns the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit)\",\n \"else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result\",\n \"(\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill\",\n \"\\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)),\",\n \"ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"See Also -------- vDataFrame[].isdate : Returns True if the vColumn category is date.\",\n \"WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha,\",\n \"---------- dropna: bool, optional If set to True, NULL values will not be\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\\",\n \"upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the\",\n \"int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop,\",\n \"index, self.alias: result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i],\",\n \"float between 0 and 1 that represents the quantile. For example: 0.25 represents\",\n \"labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\",\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if n\",\n \"--------------------------------------------------------------------------- Computes the number of matches for the regular expression in each record\",\n \"return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"distribution. mean : Average of the vColumn 'of'. min : Minimum of the\",\n \"BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query =\",\n \"at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed\",\n \"(max - min) by: list, optional vColumns used in the partition. return_trans: bool,\",\n \"vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---#\",\n \") ) return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {}\",\n \"quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\",\",\n \"func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func: str, x:\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut\",\n \"k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info +=\",\n \"isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top\",\n \"in result if elem[2] != None ] ), ) executeSQL( \\\"SELECT {}, {}\",\n \": Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types(\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x: float\",\n \"(\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def\",\n \"* COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER BY\",\n \"- cmin == 0: warning_message = \\\"Can not normalize {} using the MIN\",\n \"return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input\",\n \"({name}).\\\\n\\\" \\\"It can be the result of using previously the method on the\",\n \"\\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to the\",\n \"\\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if\",\n \"defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes\",\n \"elements). Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate :\",\n \"spider( self, by: str = \\\"\\\", method: str = \\\"density\\\", of: str =\",\n \"include_lowest: bool, optional If set to True, the lowest element of the list\",\n \"---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the\",\n \"max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum\",\n \"(use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A\",\n \"of non-missing elements q% : q quantile (ex: 50% for the median) prod\",\n \"each record of the vColumn. vDataFrame[].extract : Extracts the regular expression in each\",\n \"optimized h will be computed. pie_type: str, optional The type of pie chart.\",\n \"vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias, method ) ) else:\",\n \"= vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name,\",\n \"(self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if len(cat) == 1: lp,\",\n \"\\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events\",\n \"'03-11-1993' will filter the data when 'ts' is lesser than November 1993 the\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev =\",\n \"chart. It can also be a cutomized aggregation (ex: AVG(column1) + 5). ax:\",\n \"algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional\",\n \"\\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1]\",\n \"vColumn type must be date like (date, datetime, timestamp...) or numerical. by: str,\",\n \"the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges\",\n \"bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list.\",\n \"x: int/float, optional If the function has two arguments (example, power or mod),\",\n \"__init__( self, alias: str, transformations: list = [], parent=None, catalog: dict = {}\",\n \"ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str,\",\n \"= 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0:\",\n \"n >= 1, ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\") where\",\n \"scoring phases. xlim: tuple, optional Set the x limits of the current axes.\",\n \"[self.alias, self.ctype()] + result, } if ((is_date) and not (method == \\\"categorical\\\")) or\",\n \"breaks must be equal to the length of parameter 'labels' + 1 or\",\n \"self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds)\",\n \"Parameters ---------- by: str, optional vColumn to use to partition the data. h:\",\n \"the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional\",\n \"= ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper,\",\n \"optional Number of nbins. If empty, an optimized number of nbins will be\",\n \"rp] query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\"\",\n \"[], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified\",\n \"intervals should be closed. If set to True, the intervals will be closed\",\n \"transforms the vColumn using a time series rule. Parameters ---------- length: int Slice\",\n \"20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations\",\n \") ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\",\",\n \"+= [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] +=\",\n \") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts,\",\n \"False otherwise. Returns ------- bool True if the vColumn category is date. See\",\n \") mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\\\"Computing the\",\n \"float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int =\",\n \") executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ),\",\n \"float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar\",\n \"will be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent\",\n \"Regressor will be trained if the response is numerical (except ints and bools),\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\",\",\n \"may not use this file except in compliance with the License. # You\",\n \"self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn\",\n \"to 0, an optimised interval will be computed. nbins: int, optional Number of\",\n \"parent vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame self.parent\",\n \"0 limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"- The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {}\",\n \"y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 -\",\n \"Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"object Any amount of expressions. The expression generated will look like: even: CASE\",\n \"if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]),\",\n \"in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name]\",\n \"# / / # \\\\ / # \\\\ / # \\\\/ # _\",\n \"be seen as one column of that relation. vColumns simplify several processes with\",\n \"x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, )\",\n \"flower brackets {}. For example to apply the function: x -> x^2 +\",\n \"has two arguments (example, power or mod), 'x' represents the second argument. Returns\",\n \"filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"])\",\n \"lower_when = ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if\",\n \"vColumn records. The vColumn will be transformed. Parameters ---------- pat: str Regular expression.\",\n \"Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad'\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the\",\n \"check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ]\",\n \"is numerical (except ints and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\":\",\n \"100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT\",\n \"if method != \\\"robust_zscore\\\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations)\",\n \"Gaussian distribution to define the outliers. After normalizing the data (Z-Score), if the\",\n \"outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float,\",\n \"name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals\",\n \") ] elif method == \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The\",\n \"as categorical (No h will be picked or computed) nbins: int, optional Number\",\n \"display. Returns ------- tablesample An object containing the result. For more information, see\",\n \"for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -=\",\n \"best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h\",\n \"Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name,\",\n \"def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns\",\n \"bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method =\",\n \"vColumn. vDataFrame[].extract : Extracts the regular expression in each record of the vColumn.\",\n \"2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"]\",\n \"the vColumn. Parameters ---------- func: str Function to use to transform the vColumn.\",\n \"\\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev\",\n \"\\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\\",\n \"50% to get the median). It can also be a cutomized aggregation (ex:\",\n \"= to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"]\",\n \"= \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by,\",\n \"VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC\",\n \"self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'.\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else:\",\n \"expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({},\",\n \"/ __ `\\\\ / / # | \\\\/ / / / # |______\",\n \"func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except\",\n \"and as upper bound quantile(1-alpha) if 'use_threshold' is set to False else the\",\n \"a time series rule. Parameters ---------- length: int Slice size. unit: str, optional\",\n \"# VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import *\",\n \"Aggregates the vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate\",\n \") # ---# def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"_verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER\",\n \"is greater than the threshold it will be considered as an outlier. use_threshold:\",\n \"axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot of the\",\n \"---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True, alpha:\",\n \"method will return the mode of the vColumn. Returns ------- str/float/int vColumn nth\",\n \"1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and\",\n \"the vColumn. transformations, str : List of the different transformations. \\\"\\\"\\\" # #\",\n \"issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog,\",\n \"list List of the different aggregation. aad : average absolute deviation approx_unique :\",\n \"'{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self,\",\n \"Offset. Returns ------- tablesample An object containing the result. For more information, see\",\n \"Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str\",\n \"vColumn to the vDataFrame by using an advanced analytical function on a specific\",\n \"self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\",\",\n \"[self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise # ---# def\",\n \"n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the\",\n \"def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the\",\n \"minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage\",\n \"of one of the dummies ({name}).\\\\n\\\" \\\"It can be the result of using\",\n \"# data transformation operations, and offers beautiful graphical options. # # VerticaPy aims\",\n \"== \\\"median\\\") else \\\"AVG\\\" if by == []: if fun == \\\"AVG\\\": val\",\n \") name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\")\",\n \"assert response, ParameterError( \\\"Parameter 'response' can not be empty in case of discretization\",\n \"\\\"cut only works on numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2,\",\n \"vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame.\",\n \"-------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on an aggregation.\",\n \"str, optional The method to use to discretize the vColumn. auto : Uses\",\n \"copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters\",\n \"axes object, optional The axes to plot on. **style_kwds Any optional parameter to\",\n \"Divides the vColumn by the input element. Parameters ---------- x: float Input number.\",\n \"is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct()\",\n \"8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box\",\n \"records are in the vColumn and it returns the new vDataFrame of the\",\n \"{}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for\",\n \"be closed. If set to True, the intervals will be closed on the\",\n \"be greater or equals to 2 in case of discretization using the method\",\n \"{1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH\",\n \"vColumn bar width. Parameters ---------- method: str, optional Method to use to compute\",\n \"result = [distinct_count, self.count()] + [item[1] for item in query_result] index = [\\\"unique\\\",\",\n \"6, h: float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation = [ (\",\n \"float If the vColumn type is date like (date, datetime ...), the parameter\",\n \"---# def cut( self, breaks: list, labels: list = [], include_lowest: bool =\",\n \"transform the vColumn. abs : absolute value acos : trigonometric inverse cosine asin\",\n \"can not be empty in case of discretization using the method 'smart'.\\\" )\",\n \"Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]),\",\n \"optional Maximum number of the vColumn distinct elements to be used as categorical\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique() <\",\n \"datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"+= [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] +=\",\n \"has already the alias of one of the dummies ({name}).\\\\n\\\" \\\"It can be\",\n \"False otherwise. Returns ------- bool True if the vColumn is numerical. See Also\",\n \"---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input\",\n \"make the vDataFrame \\\"heavier\\\" if it is used to compute other vColumns. Parameters\",\n \") distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or\",\n \"the already computed aggregations to gain in performance. The catalog will be updated\",\n \"\\\", \\\".join([quote_ident(column) for column in by]) ) if (by) else \\\"\\\" ) order_by_ts\",\n \"Z-Score - The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin =\",\n \": Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\",\",\n \"or numerical. q: tuple, optional Tuple including the 2 quantiles used to draw\",\n \"|____/ / / # _____________ / / # \\\\ / / / #\",\n \"{} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in\",\n \"title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\")) or\",\n \"Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum :\",\n \"self.parent See Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap\",\n \"return self.iloc(limit=limit) # ---# def hist( self, method: str = \\\"density\\\", of: str\",\n \"> 0: column = args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else:\",\n \"Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode :\",\n \"Parameters ---------- dropna: bool, optional If set to True, NULL values will not\",\n \"= ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN\",\n \"\\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k\",\n \"bars. It is only valid if the vColumns are numerical. Optimized h will\",\n \"\\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\",\",\n \": Applies functions to the input vColumns. vDataFrame.applymap : Applies a function to\",\n \"\\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype\",\n \"min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile\",\n \"_verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias,\",\n \"[ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]),\",\n \"(pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if the\",\n \"forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool\",\n \"else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS\",\n \"this parameter to False, the function's performance can drastically decrease. Returns ------- int\",\n \"argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \"self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast\",\n \"a new vColumn to the vDataFrame by using an advanced analytical function on\",\n \"else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers\",\n \"\\\"''\\\") ) ) # ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name of the\",\n \"title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in\",\n \"the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies\",\n \"boolean. vDataFrame[].isdate : Returns True if the vColumn category is date. \\\"\\\"\\\" return\",\n \"else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return\",\n \"[0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center\",\n \"Normalization using the MinMax (min and max). (x - min) / (max -\",\n \"\\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias, dtype ) ) return\",\n \"\\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If\",\n \"= [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix)\",\n \"'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the\",\n \"the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\",\",\n \"Parameters ---------- ts: str TS (Time Series) vColumn to use to order the\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches\",\n \"<= 0: if nbins <= 0: h = self.numh() else: h = (self.max()\",\n \"or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])])\",\n \"WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\",\",\n \"library with scikit-like functionality for conducting # data science projects on data stored\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return\",\n \"[self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) )\",\n \"multiple statistical aggregations: min, max, median, unique... depending on the input method. Parameters\",\n \"# ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None),\",\n \"able to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The\",\n \"vColumn alias. transformations: list, optional List of the different transformations. Each transformation must\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return pre_comp assert\",\n \"vColumn to use to partition the data. bandwidth: float, optional The bandwidth of\",\n \"= \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by == []: if\",\n \"\\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix,\",\n \"with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT\",\n \"new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0],\",\n \"Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot of\",\n \"{}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes the statics of\",\n \"if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS\",\n \"self, alias: str, transformations: list = [], parent=None, catalog: dict = {} ):\",\n \"optional Maximum number of distinct elements for vColumns 1 and 2 to be\",\n \"/ MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME ZONE\",\n \"outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\",\",\n \"self, method: str = \\\"zscore\\\", by: list = [], return_trans: bool = False\",\n \"total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems\",\n \"title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if\",\n \"Bar Chart of the input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"str, optional The method to use to aggregate the data. count : Number\",\n \"absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the\",\n \"if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6)\",\n \"(method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result =\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the input\",\n \"Renames the vColumn by dropping the current vColumn and creating a copy with\",\n \"------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna:\",\n \"[str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if\",\n \"def discretize( self, method: str = \\\"auto\\\", h: float = 0, nbins: int\",\n \"# ---# def plot( self, ts: str, by: str = \\\"\\\", start_date: Union[str,\",\n \"Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian\",\n \"\\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ]\",\n \"/ TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns -------\",\n \"CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events\",\n \"\\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]),\",\n \"h > 0.0001: h = round(h, 4) elif h > 0.000001: h =\",\n \"float = 4.0, use_threshold: bool = True, alpha: float = 0.05, ): \\\"\\\"\\\"\",\n \"median and two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn\",\n \"int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by\",\n \"\\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns -------\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"as an outlier. use_threshold: bool, optional Uses the threshold instead of the 'alpha'\",\n \"method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ]\",\n \"the vColumn. The vColumn will be transformed. Parameters ---------- start: int Start of\",\n \"[str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\"\",\n \"the power of another number round : rounds a value to a specified\",\n \"+= ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else\",\n \"the vColumn and it returns the new vDataFrame of the search. Parameters ----------\",\n \"(0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] =\",\n \"column must be numerical to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations)\",\n \"to be used as categorical (No h will be picked or computed) h:\",\n \"start: int Start of the slicing. step: int Size of the slicing. Returns\",\n \"of the vColumn. The aggregations used are the median and two input quantiles.\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut(\",\n \"pt_events FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS index,\",\n \"check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\",\",\n \"WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp +\",\n \"\\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1,\",\n \"the vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\"\",\n \"= method.lower() if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ---------- x:\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn.\",\n \"(float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {} > {} THEN\",\n \"**kwargs Any optional parameter to pass to the geopandas plot function. For more\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns\",\n \"\\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER\",\n \") ) return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \") distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and\",\n \"i] THEN argv[2 * i + 1] ... ELSE argv[n] END Returns -------\",\n \"in the vColumn and it returns the new vDataFrame of the search. Parameters\",\n \"sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[\",\n \"specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val,\",\n \"if (category in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"[sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"]\",\n \"), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg,\",\n \"usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\"\",\n \"ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct\",\n \"Computes the number of matches for the regular expression in each record of\",\n \"\\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range\",\n \"= float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str = \\\"auto\\\",\",\n \"method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) #\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the\",\n \"--------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int, optional Number\",\n \"in Vertica, taking advantage Vertica’s # speed and built-in analytics and machine learning\",\n \"\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] )\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"[float, int])]) assert (lower != None) or (upper != None), ParameterError( \\\"At least\",\n \"PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75)\",\n \"for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype,\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest :\",\n \"bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim:\",\n \"COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP\",\n \"boxplot( self, by: str = \\\"\\\", h: float = 0, max_cardinality: int =\",\n \"float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0\",\n \"NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if\",\n \"to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \"# ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0]\",\n \"result[0][0] if not (dropna): n = \\\"\\\" if (n == 1) else str(int(n))\",\n \"numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self):\",\n \"and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\"\",\n \"self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods\",\n \"be gathered together to create a new category : 'Others'. cat_priority: list, optional\",\n \"if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif\",\n \"fillna( self, val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\", by: list\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"generated will look like: even: CASE ... WHEN vColumn = argv[2 * i]\",\n \"of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\",\",\n \"Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert\",\n \"0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float,\",\n \"0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0\",\n \"- sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method ==\",\n \"be defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality: int,\",\n \"gain in performance. The catalog will be updated when the parent vDataFrame is\",\n \"method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if\",\n \"most occurent elements to return. dropna: bool, optional If set to True, NULL\",\n \"/ # \\\\ / / / # \\\\_______/ / / # ______ /\",\n \"( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"used to name the new categories. If empty, names will be generated. include_lowest:\",\n \"verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim,\",\n \"right: bool, optional How the intervals should be closed. If set to True,\",\n \"all the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql):\",\n \"else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna)\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\"\",\n \"could work if it is part of the DB version you are using.\",\n \"new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans:\",\n \"distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result for\",\n \"transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn)\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ]\",\n \"response is numerical (except ints and bools), a RF Classifier otherwise. Example: Write\",\n \"[str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime,\",\n \"str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds,\",\n \"\\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"# ---# def iloc(self, limit: int = 5, offset: int = 0): \\\"\\\"\\\"\",\n \": Keeps the topk most frequent categories and merge the other into one\",\n \"check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0: offset\",\n \"of the learning and scoring phases. xlim: tuple, optional Set the x limits\",\n \"AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) )\",\n \"element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj, )\",\n \"\\\"\\\" ) upper_when = ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper,\",\n \"\\\"\\\", by: list = [], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills\",\n \"was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right:\",\n \"= ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific\",\n \"\\\"float\\\"]: warning_message = ( \\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message,\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts,\",\n \"______ __ __ __ __ __ __ __ # /\\\\ \\\\ / /\",\n \"1 if drop_first else 0 for k in range(len(distinct_elements) - n): name =\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return\",\n \": Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace :\",\n \"equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result]\",\n \": List of the different transformations. \\\"\\\"\\\" # # Special Methods # #\",\n \"* result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER\",\n \"Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\"\",\n \"the vColumns outliers using the input method. Parameters ---------- method: str, optional Method\",\n \"{} IS NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"Applies a function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [\",\n \"not use this file except in compliance with the License. # You may\",\n \"def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool\",\n \"result if elem[2] != None ] ), ) executeSQL( \\\"SELECT {}, {} FROM\",\n \"value acos : trigonometric inverse cosine asin : trigonometric inverse sine atan :\",\n \"self.parent # ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by,\",\n \"the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and 2\",\n \"x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\"\",\n \"= 0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition\",\n \"to use to partition the data. h: float, optional Interval width if the\",\n \"return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for elem in\",\n \"ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 ) result =\",\n \"Warning) return self elif n == 1: try: result = executeSQL( \\\"SELECT {},\",\n \"be numerical for Normalization\\\") return self.parent # ---# def nsmallest(self, n: int =\",\n \"elem[1] != None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"FROM {} WHERE {} IS NOT NULL GROUP BY 1) x ORDER BY\",\n \"1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method ==\",\n \"x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn.\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar\",\n \"self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"Numerical vColumn to use when the parameter method is set to 'cat_stats'. Returns\",\n \"{}, {} AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y,\",\n \"this parameter will increase the precision but will also increase the time of\",\n \"approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"= \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None,\",\n \"return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str,\",\n \"/\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\\",\n \"/ {}) * {} || ';' || (FLOOR({} / {}) * {} +\",\n \"self.alias, n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query,\",\n \"= \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS\",\n \"or not (labels), ParameterError( \\\"Length of parameter breaks must be equal to the\",\n \"6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\",\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---#\",\n \"Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to\",\n \"than November 1993 the 3rd. area: bool, optional If set to True, draw\",\n \"elem in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h)\",\n \"0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method\",\n \"agreed to in writing, software # distributed under the License is distributed on\",\n \"return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self,\",\n \"AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += (\",\n \"assert x != 0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} /\",\n \") ) elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT *\",\n \"by: list = [], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the\",\n \"function to the vColumn. Parameters ---------- func: str Function to use to transform\",\n \"to find the most relevant interval to use for the discretization. topk :\",\n \"expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the\",\n \"you are using. Returns ------- tablesample An object containing the result. For more\",\n \"def median( self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"\\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError(\",\n \"meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]),\",\n \"of the slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent\",\n \"None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"------- float sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), )\",\n \"\\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor = 0 for elem\",\n \"title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075,\",\n \"feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent\",\n \"Maximum number of distinct elements for vColumns 1 and 2 to be used\",\n \"expression in each record of the vColumn. vDataFrame[].extract : Extracts the regular expression\",\n \"order the data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else\",\n \"Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional\",\n \"convert the vColumn. If this parameter is equal to 0, an optimised interval\",\n \"in the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops\",\n \"\\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---#\",\n \"trans = ( \\\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE\",\n \"aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n,\",\n \"\\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and\",\n \"nbins: int, optional Number of bins used for the discretization (must be >\",\n \"Clips the vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha)\",\n \"(pre_comp != None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be\",\n \"def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness\",\n \"in the final generated SQL code. Note: Dropping a vColumn can make the\",\n \"( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] +\",\n \"max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\"\",\n \"/ # \\\\ / / / # \\\\/ / / # / /\",\n \"self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int = 1):\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of,\",\n \"self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---#\",\n \"in case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response)\",\n \"AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY\",\n \"self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"]\",\n \"only available on type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\",\",\n \"[str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"[bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in\",\n \"float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"min : minimum mode : most occurent element percent : percent of non-missing\",\n \": logarithm log10 : base 10 logarithm mod : remainder of a division\",\n \"prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"',\",\n \"= \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {},\",\n \"LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the\",\n \"\\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---#\",\n \": Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using\",\n \"float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple\",\n \"tuple] = (6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds,\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x,\",\n \"on an aggregation. Parameters ---------- method: str, optional The method to use to\",\n \"and two input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to\",\n \"= 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the vColumn {}\",\n \"self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif method ==\",\n \"self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \\\"\\\"\\\"\",\n \"\\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"): trans = ( \\\"'['\",\n \"\\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem ==\",\n \"a default function to the vColumn. Parameters ---------- func: str Function to use\",\n \"self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias),\",\n \"func: str Function to use to transform the vColumn. abs : absolute value\",\n \"elem[2] != None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT\",\n \"# ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() #\",\n \"func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\",\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar)))\",\n \"return \\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"the next whole number cos : trigonometric cosine cosh : hyperbolic cosine cot\",\n \"result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by,\",\n \": product range : difference between the max and the min sem :\",\n \"min, max, median, unique... depending on the input method. Parameters ---------- method: str,\",\n \"float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"Special Methods # # ---# def __init__( self, alias: str, transformations: list =\",\n \"count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns\",\n \"the vColumn using 'count' (Number of non-Missing elements). Returns ------- int number of\",\n \"Of Evidence (WOE) Table. It tells the predictive power of an independent variable\",\n \"sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] =\",\n \"!= None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already\",\n \"\\\"The parameter 'numcol' must be a vDataFrame column if the method is 'cat_stats'\\\"\",\n \"FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the\",\n \"-------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---#\",\n \"title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{}\",\n \"\\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] +\",\n \"func: str, Function in pure SQL used to transform the vColumn. The function\",\n \"'sem' (standard error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate\",\n \") except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\",\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time series.\",\n \"[0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by,\",\n \"[store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies\",\n \"[bool]), (\\\"n\\\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\")\",\n \"= argv[2 * i] THEN argv[2 * i + 1] ... END odd\",\n \"return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str):\",\n \"AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table\",\n \"h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"of matches for the regular expression in each record of the vColumn. vDataFrame[].str_replace\",\n \"will be transformed. Parameters ---------- start: int Start of the slicing. step: int\",\n \"smart : Uses the Random Forest on a response column to find the\",\n \"gathered together to create a new category : 'Others'. cat_priority: list, optional List\",\n \"\\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans\",\n \"step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters\",\n \"\\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\\",\n \"str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of\",\n \"3rd. area: bool, optional If set to True, draw an Area Plot. step:\",\n \"in each of the vColumn record by an input value. The vColumn will\",\n \"= 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message =\",\n \"Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str,\",\n \"[int, float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0: offset = max(0,\",\n \"return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {} AS ord, {}::int\",\n \"Returns the n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns\",\n \"float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert (method != \\\"cat_stats\\\")\",\n \"transform the vColumn. The function variable must be composed of two flower brackets\",\n \"GROUP BY 1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT {}, ord,\",\n \"vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple children vColumns\",\n \"the outliers by the NULL value. winsorize : Clips the vColumn using as\",\n \"parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias,\",\n \"smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str =\",\n \"bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train\",\n \"= {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ]\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then\",\n \"if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) #\",\n \"non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"= \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the\",\n \"Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate\",\n \"(Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"\\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See\",\n \"occurent element percent : percent of non-missing elements q% : q quantile (ex:\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method ==\",\n \"to {}.\\\".format( self.alias, dtype ) ) return self.parent except Exception as e: raise\",\n \"= \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the\",\n \"\\\"Can not normalize {} using the MIN and the MAX. MAX = MIN\",\n \"== \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}'\",\n \"import Iterable from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities\",\n \"optimized h will be computed. ax: Matplotlib axes object, optional The axes to\",\n \"considered as categorical. numcol: str, optional Numerical vColumn to use when the parameter\",\n \"equals to 2 in case of discretization using the method 'smart'.\\\" ) assert\",\n \"and # limitations under the License. # # |_ |~) _ _| _\",\n \"partitioned by the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns\",\n \"Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name\",\n \"= 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters\",\n \"self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers :\",\n \"try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4}\",\n \"dtype ) ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn\",\n \"elements to return. dropna: bool, optional If set to True, NULL values will\",\n \"TypeError( \\\"The response column must be numerical to use a mean encoding\\\" )\",\n \"True, NULL values will not be considered during the computation. Returns ------- tablesample\",\n \"self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\")\",\n \"using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes\",\n \"next whole number cos : trigonometric cosine cosh : hyperbolic cosine cot :\",\n \"Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method,\",\n \"> {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha =\",\n \"nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin ==\",\n \"def spider( self, by: str = \\\"\\\", method: str = \\\"density\\\", of: str\",\n \"{})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\"\",\n \") ] else: warning_message = \\\"Can not normalize {} using a Robust Z-Score\",\n \"to partition the data. bandwidth: float, optional The bandwidth of the kernel. kernel:\",\n \"max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS\",\n \"Warning : SQL code generation will be slower if the vDataFrame has been\",\n \"drawn. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"[ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\",\",\n \"WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias,\",\n \") else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent #\",\n \"return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75)\",\n \"= sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h =\",\n \"unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index = [\",\n \"0: index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <= 0:\",\n \"length of parameter 'labels' + 1 or parameter 'labels' must be empty.\\\" )\",\n \"x: float A float between 0 and 1 that represents the quantile. For\",\n \"columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index =\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field from\",\n \"= True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args,\",\n \"\\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\":\",\n \"step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self,\",\n \"MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND\",\n \"= [ item[0] for item in executeSQL( query=query, title=\\\"Computing the average of the\",\n \"\\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format(\",\n \"self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {} FROM\",\n \"or not (is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} ||\",\n \"input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"transformed using a mean encoding with {} as Response Column.\\\".format( self.alias, response )\",\n \"assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\" )\",\n \"OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in\",\n \"Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes\",\n \"method == \\\"zscore\\\": if n == 0: nullifzero = 0 avg, stddev =\",\n \"encoding of a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) #\",\n \"their respective average. null : Replaces the outliers by the NULL value. winsorize\",\n \"math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max =\",\n \"Also -------- vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\",\",\n \"dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number\",\n \"NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid\",\n \"to the lower bound itself and the values higher than the upper bound\",\n \"filter the data when 'ts' is greater than November 1993 the 3rd. area:\",\n \"\\\", \\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY\",\n \"returned. By setting this parameter to False, the function's performance can drastically decrease.\",\n \"int = -1, k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict\",\n \"options. # # VerticaPy aims to do all of the above. The idea\",\n \"(\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements =\",\n \"(PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\",\",\n \"\\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations\",\n \"response_cat == [0, 1], TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y)\",\n \"n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See\",\n \"(\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\"\",\n \"avg # ---# def bar( self, method: str = \\\"density\\\", of: str =\",\n \"\\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\"\",\n \"cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION\",\n \"= \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index < 0: index\",\n \"if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha =\",\n \"write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the\",\n \"x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n:\",\n \"0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\"\",\n \"categorical : Uses only categorical aggregations during the computation. cat_stats : Computes statistics\",\n \"null, 1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns used\",\n \"plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot\",\n \"Computes the optimal vColumn bar width. Parameters ---------- method: str, optional Method to\",\n \"WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def\",\n \"TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct()\",\n \"if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT\",\n \"\\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by\",\n \"encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]),\",\n \"vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func)\",\n \"h <= 0: if nbins <= 0: h = self.numh() else: h =\",\n \"used for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid\",\n \"= \\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"True if the vColumn category is date. vDataFrame[].isnum : Returns True if the\",\n \"the vColumn by transforming the values lesser than the lower bound to the\",\n \"sem : standard error of the mean skewness : skewness sum : sum\",\n \"query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query )\",\n \"{}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias,\",\n \") self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name,\",\n \") return parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold:\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def\",\n \"non-Missing elements). Returns ------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate\",\n \"ln : natural logarithm log : logarithm log10 : base 10 logarithm mod\",\n \"discretization. topk : Keeps the topk most frequent categories and merge the other\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the\",\n \"The idea is simple: instead of moving # data around for processing, VerticaPy\",\n \"donut : Donut chart. rose : Rose chart. It can also be a\",\n \"in kwargs: column = kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column\",\n \"distribution to identify outliers. After normalizing the data (Z-Score), if the absolute value\",\n \"name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model\",\n \"Interpolation). mean : Average. median : median. mode : mode (most occurent element).\",\n \"axes to plot on. **style_kwds Any optional parameter to pass to the Matplotlib\",\n \"-------- vDataFrame.astype : Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype,\",\n \"* ## # # __ __ ______ ______ __ __ __ __ __\",\n \"if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try:\",\n \") else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations +=\",\n \"Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {}\",\n \"\\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\\",\n \"\\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int)))\",\n \"p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query = \\\"WITH vdf_table\",\n \"self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\",\",\n \"will be gathered together to create a new category : 'Others'. cat_priority: list,\",\n \"\\\" if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One\",\n \"TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the\",\n \"[int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans,\",\n \"None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"None else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", ) for elem\",\n \"\\\".join([quote_ident(column) + desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS)\",\n \"/ ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS /\",\n \"method will return the transformation used instead of the parent vDataFrame. This parameter\",\n \"and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query\",\n \"5). of: str, optional The vColumn to use to compute the aggregation. h:\",\n \"element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def __len__(self): return int(self.count())\",\n \"\\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\",\",\n \"[bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x *\",\n \"= vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\":\",\n \"= self.count() if (method == \\\"mode\\\") and (val == None): val = self.mode(dropna=True)\",\n \"---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input\",\n \"Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad\",\n \"type must be date like (date, datetime, timestamp...) or numerical. q: tuple, optional\",\n \"\\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events\",\n \"\\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message = \\\"Can not normalize {}\",\n \"vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step,\",\n \"types to varchar. same_freq : Computes bins with the same number of elements.\",\n \"ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---#\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\"\",\n \"\\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM\",\n \"except Exception as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn\",\n \"< {} THEN {} WHEN {} > {} THEN {} ELSE {} END)\\\".format(\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product\",\n \"\\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index,\",\n \"very useful for testing to be able to look at the final transformation.\",\n \"print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"this method will return the mode of the vColumn. Returns ------- str/float/int vColumn\",\n \"return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the\",\n \"on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,\",\n \"(\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\"\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str):\",\n \": Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query\",\n \"record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each\",\n \"in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs):\",\n \"For example, to check if Badr and Fouad are in the vColumn. You\",\n \"/ / / # |____/ / / # _____________ / / # \\\\\",\n \"\\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE\",\n \"NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title\",\n \"category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self,\",\n \"if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return\",\n \"max_cardinality + 1) and (method != \\\"numerical\\\")) or not (is_numeric) or (method ==\",\n \"Value (IV) / Weight Of Evidence (WOE) Table. It tells the predictive power\",\n \"Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset,\",\n \"Returns ------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin :\",\n \"verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from\",\n \"return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"str, optional vColumn to use to partition the data. method: str, optional The\",\n \"(self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if (method ==\",\n \"the different records. For example, to check if Badr and Fouad are in\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x:\",\n \"+ 2\\\". copy_name: str, optional If not empty, a copy will be created\",\n \"[str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins,\",\n \"'k' must be greater or equals to 2 in case of discretization using\",\n \"store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the\",\n \"DB type. Returns ------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype =\",\n \"on an aggregation. Parameters ---------- by: str, optional vColumn to use to partition\",\n \"be updated when the parent vDataFrame is modified. Attributes ---------- alias, str :\",\n \"list, labels: list = [], include_lowest: bool = True, right: bool = True,\",\n \"std). (x - avg) / std robust_zscore : Normalization using the Robust Z-Score\",\n \"of matches for the regular expression in each record of the vColumn. The\",\n \"transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn\",\n \"an independent variable in relation to the dependent variable. Parameters ---------- y: str\",\n \"self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field from the\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method\",\n \"vDataFrame represents the entire relation, a vColumn can be seen as one column\",\n \"# ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the\",\n \"self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\",\",\n \"range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} =>\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert\",\n \"isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\",\",\n \"\\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in\",\n \"\\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which\",\n \"ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk,\",\n \"to_replace: str Regular expression to replace. value: str, optional New value. Returns -------\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the\",\n \"bool, optional Drops the first dummy to avoid the creation of correlated features.\",\n \"\\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x)\",\n \"UNION ALL \\\".join(query) ) title = \\\"Describes the statics of {} partitioned by\",\n \"The less frequent elements will be gathered together to create a new category\",\n \": average absolute deviation approx_unique : approximative cardinality count : number of non-missing\",\n \"total) / self.parent.shape()[0] ) except: pass total = int(total) conj = \\\"s were\",\n \"cast, ) tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in\",\n \"limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category() ==\",\n \"return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"(WOE) Table. It tells the predictive power of an independent variable in relation\",\n \"global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method,\",\n \"= method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp !=\",\n \"# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in\",\n \"be greater or equal to 2.\\\" ) assert len(breaks) == len(labels) + 1\",\n \"> 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was\",\n \"[2018-2022] Micro Focus or one of its affiliates. # Licensed under the Apache\",\n \"to varchar. same_freq : Computes bins with the same number of elements. same_width\",\n \"return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [ (\",\n \"self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias)\",\n \"= round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end =\",\n \"Verifies if the regular expression is in each of the vColumn records. The\",\n \"# ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n\",\n \"{}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"the vColumn. Parameters ---------- limit: int, optional Number of elements to display. Returns\",\n \"---------- breaks: list List of values used to cut the vColumn. labels: list,\",\n \"/ ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"the input element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent\",\n \"only valid if the vColumns are numerical. Optimized h will be computed if\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe :\",\n \"Input number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"mean encoding was successfully done.\\\") return self.parent # ---# def median( self, approx:\",\n \"\\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str,\",\n \"[str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem\",\n \"of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use\",\n \"categorical (No h will be picked or computed) ax: Matplotlib axes object, optional\",\n \"the categorical vColumns. bfill : Back Propagation of the next element (Constant Interpolation).\",\n \"= \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"total += sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method,\",\n \"corresponds to an aggregation. vColumns will memorize the already computed aggregations to gain\",\n \"bandwidth of the kernel. kernel: str, optional The method used for the plot.\",\n \"as percents. Parameters ---------- k: int, optional Number of most occurent elements to\",\n \"Fouad are in the vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"]\",\n \"able to solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for\",\n \"DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query,\",\n \"{} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias,\",\n \"[ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ),\",\n \"\\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table\",\n \"\\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method: str = \\\"density\\\", of:\",\n \"occurent elements, how often they occur, and other statistical information. Parameters ---------- k:\",\n \"a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first,\",\n \"Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\",\",\n \": Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True if\",\n \"'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS\",\n \"to use to discretize the vColumn. auto : Uses method 'same_width' for numerical\",\n \"in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)\",\n \"tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError(\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of\",\n \"vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to replace. value:\",\n \"k most occurent elements and their distributions as percents. Parameters ---------- k: int,\",\n \"def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent\",\n \"vColumn using a user-defined encoding. Parameters ---------- argv: object Any amount of expressions.\",\n \"set to True, NULL values will not be considered during the computation. Returns\",\n \"{}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result\",\n \"try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS\",\n \"{} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"]\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({}) OVER\",\n \"other into one unique category. h: float, optional The interval size to convert\",\n \"the vDataFrame parent and do not apply it. This parameter is very useful\",\n \"new vColumn labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types(\",\n \"str) or not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val,\",\n \"= result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)),\",\n \"+ index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part\",\n \"result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns\",\n \"Series of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut :\",\n \"vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn.\",\n \"relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias: str vColumn\",\n \"all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k\",\n \"element (ex: top1 for the mode) topk_percent : kth most occurent element density\",\n \"{}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias,\",\n \"numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during the computation.\",\n \"ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\") where = \\\" WHERE\",\n \"float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame\",\n \"\\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type == \\\"donut\\\" else False\",\n \"{0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET\",\n \"of most occurent elements to return. dropna: bool, optional If set to True,\",\n \"list List of values used to cut the vColumn. labels: list, optional Labels\",\n \"self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for\",\n \"{}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ),\",\n \"self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def\",\n \"float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median,\",\n \"input value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a vColumn\",\n \"str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the first\",\n \"---# def __init__( self, alias: str, transformations: list = [], parent=None, catalog: dict\",\n \"empty\\\\nIf you want to normalize by grouping by elements, please use a method\",\n \"used to transform the vColumn. The function variable must be composed of two\",\n \"be filtered. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional Returns the\",\n \"k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")]\",\n \"= [order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\",\",\n \"{}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---#\",\n \"# ---# def discretize( self, method: str = \\\"auto\\\", h: float = 0,\",\n \"Fills the vColumns outliers using the input method. Parameters ---------- method: str, optional\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5):\",\n \"drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif method\",\n \"vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn)\",\n \"skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"in sublist] # ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn\",\n \"method: str, optional The method to use to discretize the vColumn. auto :\",\n \"len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes\",\n \"has already the alias {name}.\\\\nBy changing the parameter 'name', you'll be able to\",\n \"Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully\",\n \"the range plot of the vColumn. The aggregations used are the median and\",\n \") if (is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"])\",\n \"Function to use to transform the vColumn. abs : absolute value acos :\",\n \"self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum).\",\n \"= to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method !=\",\n \": number of non-missing elements cvar : conditional value at risk dtype :\",\n \"\\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2,\",\n \"the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a\",\n \"{} AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y,\",\n \"or computed) ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"See Also -------- vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{}\",\n \"percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS\",\n \"self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem for\",\n \"# \\\\ / / / # \\\\ / / / # \\\\_______/ /\",\n \"BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER\",\n \"(n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"total, query, nth_elems = nb, [], [] while total < int(float(count / int(nbins)))\",\n \"Applies a function to all the vColumns. vDataFrame.eval : Evaluates a customized expression.\",\n \"max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category\",\n \"It can also be a cutomized aggregation (ex: AVG(column1) + 5). of: str,\",\n \"KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema,\",\n \"= \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method:\",\n \"{} was converted to {}.\\\".format( self.alias, dtype ) ) return self.parent except Exception\",\n \"), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor = 0 for\",\n \"check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\",\",\n \"---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype\",\n \"together to create a new category : 'Others'. cat_priority: list, optional List of\",\n \"is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the\",\n \"input vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn to\",\n \"def topk(self, k: int = -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"max_cardinality: int, optional Cardinality threshold to use to determine if the vColumn will\",\n \"1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]:\",\n \"[elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if\",\n \"Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns -------\",\n \"for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if\",\n \"None: warning_message = \\\"The vColumn {} has no mode (only missing values).\\\\nNothing was\",\n \"histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by,\",\n \"the vColumn using an input 'quantile'. Parameters ---------- x: float A float between\",\n \"__ __ __ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\\",\n \"pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing\",\n \"---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input\",\n \"alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to solve this issue.\\\"\",\n \"if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"]\",\n \"== None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\",\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn\",\n \"to_tablesample(query, title=title) # ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \"= self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {} must be\",\n \"else \\\"\\\" if index < 0: index += self.parent.shape()[0] query = \\\"SELECT {}{}\",\n \"For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\"\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"\\\"Not enough values to compute the Equal Frequency discretization\\\" ) total, query, nth_elems\",\n \"# ---# def density( self, by: str = \\\"\\\", bandwidth: float = 1.0,\",\n \"max_cardinality: int = 6, nbins: int = 0, h: float = 0, ax=None,\",\n \"1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY\",\n \"the information will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent\",\n \"0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie\",\n \"the alias {name}.\\\\nBy changing the parameter 'name', you'll be able to solve this\",\n \"\\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions +=\",\n \"outliers. After normalizing the data (Z-Score), if the absolute value of the record\",\n \"not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the parameter\",\n \"self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT\",\n \"vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method,\",\n \"fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool =\",\n \"WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See\",\n \"verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import *\",\n \"try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {}\",\n \"\\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\",\",\n \"else the lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution\",\n \"to 'smart'. return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent\",\n \"xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, )\",\n \"- min) by: list, optional vColumns used in the partition. return_trans: bool, optimal\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality,\",\n \"mechanism to sequentialize # data transformation operations, and offers beautiful graphical options. #\",\n \"float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"\\\"The response column must be numerical to use a mean encoding\\\" ) max_floor\",\n \"+= self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit\",\n \"index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ]\",\n \"be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also --------\",\n \"{} was transformed using a mean encoding with {} as Response Column.\\\".format( self.alias,\",\n \"vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate : Returns True\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on an\",\n \"[str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\",\",\n \"int Slice size. unit: str, optional Slice size unit. For example, it can\",\n \"self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem]\",\n \"self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn {} has no mode\",\n \"/ HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM /\",\n \"SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY\",\n \"'x' represents the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"list, optional List of the different transformations. Each transformation must be similar to\",\n \"Also -------- vDataFrame.bar : Draws the Bar Chart of the input vColumns based\",\n \"to compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct\",\n \"self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of\",\n \"(1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold,\",\n \"AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS\",\n \"LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \\\"UNION\",\n \"method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used to\",\n \"Returns the head of the vColumn. Parameters ---------- limit: int, optional Number of\",\n \"self, method: str = \\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\"\",\n \"The vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"),\",\n \"expression is in each of the vColumn records. vDataFrame[].str_count : Computes the number\",\n \"auto : Regular pie chart. donut : Donut chart. rose : Rose chart.\",\n \"\\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python\",\n \"offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype()\",\n \"using a Z-Score - The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"{\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth,\",\n \"{} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end\",\n \"{} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE {} =\",\n \"---------- func: list List of the different aggregation. aad : average absolute deviation\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"and merge the other into one unique category. h: float, optional The interval\",\n \"# ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods #\",\n \"the k most occurent elements, how often they occur, and other statistical information.\",\n \"events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE\",\n \"\\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str,\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the\",\n \"NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll\",\n \"self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6,\",\n \"\\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM (SELECT {},\",\n \"h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\",\",\n \"\\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY\",\n \"\\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]:\",\n \"(ex: top1 for the mode) topk_percent : kth most occurent element density unique\",\n \"tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) /\",\n \"return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query\",\n \"total) except Exception as e: self.transformations = [elem for elem in copy_trans] raise\",\n \"self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}'\",\n \"bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional The method\",\n \"result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\",\",\n \"while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total +=\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot :\",\n \"else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates\",\n \"(\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def\",\n \"See Also -------- vDataFrame.astype : Converts the vColumns to the input type. \\\"\\\"\\\"\",\n \"done.\\\") return self.parent # ---# def median( self, approx: bool = True, ):\",\n \"\\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\":\",\n \"\\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted\",\n \"new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert\",\n \"to fill the vColumn outliers. mean : Replaces the upper and lower outliers\",\n \"---------- name: str Name of the copy. Returns ------- vDataFrame self.parent See Also\",\n \"---------- length: int Slice size. unit: str, optional Slice size unit. For example,\",\n \".transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return\",\n \"optional Method to use to fill the vColumn outliers. mean : Replaces the\",\n \"method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, nbins:\",\n \").format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"this parameter to False, the function's performance can drastically decrease. Returns ------- float/str\",\n \"STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1)\",\n \"for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info\",\n \"or equals to 2 in case of discretization using the method 'topk'\\\" )\",\n \"sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \") if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self,\",\n \"under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to\",\n \"# \\\\ / # \\\\/ # _ # \\\\ / _ __|_. _\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n ==\",\n \"\\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\",\n \"\\\\/ / / # / / # / / # \\\\ / #\",\n \"Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has\",\n \"/ self.parent.shape()[0] ) except: pass total = int(total) conj = \\\"s were \\\"\",\n \"get_dummies # ---# def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"{}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax,\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ #\",\n \"text / binary / spatial / uuid / undefined Returns ------- str vColumn\",\n \"unique : cardinality (count distinct) var : variance Other aggregations could work if\",\n \"def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in\",\n \"vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\",\",\n \"represents the quantile. For example: 0.25 represents Q1. approx: bool, optional If set\",\n \"to apply the function: x -> x^2 + 2 use \\\"POWER({}, 2) +\",\n \"len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())]\",\n \"[bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only\",\n \"Regular pie chart. donut : Donut chart. rose : Rose chart. It can\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format(\",\n \": Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by]\",\n \"like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to use to\",\n \") assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical / date-like\",\n \"] expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\"\",\n \"{}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h,\",\n \"# VerticaPy aims to do all of the above. The idea is simple:\",\n \"def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 #\",\n \"'response' can not be empty in case of discretization using the method 'smart'.\\\"\",\n \"return self elif method == \\\"minmax\\\": if n == 0: nullifzero = 0\",\n \"(method == \\\"median\\\") else \\\"AVG\\\" if by == []: if fun == \\\"AVG\\\":\",\n \"func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"matches for the regular expression in each record of the vColumn. vDataFrame[].str_replace :\",\n \"element). 0ifnull : 0 when the vColumn is null, 1 otherwise. expr: str,\",\n \") tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\",\",\n \"= self.count() nb = int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not\",\n \"AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format( self.alias, y,\",\n \"the vColumn 'of' (ex: 50% to get the median). It can also be\",\n \"Returns the category of the vColumn. The category will be one of the\",\n \"(SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0}\",\n \"CONDITIONS OF ANY KIND, either express or implied. # See the License for\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements\",\n \"max : maximum mean : average median : median min : minimum mode\",\n \") warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\"\",\n \"nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {}\",\n \"self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax\",\n \"method is in ffill|pad|bfill|backfill then 'order_by' must be a list of at least\",\n \"\\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val +=\",\n \"= xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns):\",\n \"numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean.\",\n \"head of the vColumn. Parameters ---------- limit: int, optional Number of elements to\",\n \"approximate quantile is returned. By setting this parameter to False, the function's performance\",\n \"compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and\",\n \"elem in order_by] + by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method\",\n \"optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See\",\n \"ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE & IV of\",\n \"DAY / DECADE / DOQ / DOW / DOY / EPOCH / HOUR\",\n \"\\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn\",\n \"Aggregates the vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate\",\n \"trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube root ceil\",\n \"than November 1993 the 3rd. plot_median: bool, optional If set to True, the\",\n \"method. auto : Sets the method to 'numerical' if the vColumn is numerical\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns ------- int\",\n \"(labels), ParameterError( \\\"Length of parameter breaks must be equal to the length of\",\n \": Minimum of the vColumn 'of'. max : Maximum of the vColumn 'of'.\",\n \"= 4.0, use_threshold: bool = True, alpha: float = 0.05 ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"the data when 'ts' is greater than November 1993 the 3rd. area: bool,\",\n \"] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from\",\n \"return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"\\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The\",\n \"(\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM\",\n \"import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin\",\n \"be transformed. Parameters ---------- field: str The field to extract. It must be\",\n \"events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0 THEN\",\n \"compliance with the License. # You may obtain a copy of the License\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method,\",\n \"assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be a\",\n \"max and the min sem : standard error of the mean skewness :\",\n \"The expression generated will look like: even: CASE ... WHEN vColumn = argv[2\",\n \"vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self, val:\",\n \"float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if\",\n \"\\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"not (result) else result[0][0] if not (dropna): n = \\\"\\\" if (n ==\",\n \"Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \\\"\\\"\\\"\",\n \"= \\\"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL GROUP\",\n \"# ---# def pie( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the\",\n \"range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize(\",\n \"category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100\",\n \"or parameter 'labels' must be empty.\\\" ) conditions, column = [], self.alias for\",\n \"[str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must\",\n \"life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations, and\",\n \"name. \\\\u26A0 Warning : SQL code generation will be slower if the vDataFrame\",\n \"for elem in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not\",\n \"else: warning_message = \\\"Can not normalize {} using a Robust Z-Score - The\",\n \"for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax =\",\n \"'mad' (median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate :\",\n \"/ / # \\\\ / / / # \\\\ / / / #\",\n \"by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else\",\n \"result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp,\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix =\",\n \"method: str = \\\"auto\\\", h: float = 0, nbins: int = -1, k:\",\n \"------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks\",\n \"= max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT\",\n \"!= None else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", ) for\",\n \"--------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating a copy\",\n \"=> {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr,\",\n \"result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], } return tablesample(values) # ---#\",\n \"idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else\",\n \"return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) #\",\n \"WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER\",\n \"-------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes\",\n \"expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k],\",\n \"method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for\",\n \"to skip. Returns ------- tablesample An object containing the result. For more information,\",\n \"final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \\\"\\\"\\\"\",\n \"Tuple including the 2 quantiles used to draw the Plot. start_date: str /\",\n \"brackets {}. For example to apply the function: x -> x^2 + 2\",\n \"elem == None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem]\",\n \"for item in sublist] # ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and their\",\n \"Aggregates the vColumn using 'var' (Variance). Returns ------- float var See Also --------\",\n \"frequent elements will be gathered together to create a new category : 'Others'.\",\n \"pie( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int =\",\n \"query = \\\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM\",\n \"== \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method\",\n \"filter the data when 'ts' is greater than November 1993 the 3rd. plot_median:\",\n \"Aggregates the vColumn using 'avg' (Average). Returns ------- float average See Also --------\",\n \"parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool =\",\n \"value. The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to\",\n \"[int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity\",\n \"int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None) or (upper != None),\",\n \": variance Other aggregations could work if it is part of the DB\",\n \"which that stores all user transformations. If the vDataFrame represents the entire relation,\",\n \"(\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"to define the outliers. After normalizing the data (Z-Score), if the absolute value\",\n \"'{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts\",\n \"using a time series rule. Parameters ---------- length: int Slice size. unit: str,\",\n \"self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins if h\",\n \"Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str):\",\n \"# ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns -------\",\n \"# Unless required by applicable law or agreed to in writing, software #\",\n \"one unique category. h: float, optional The interval size to convert to use\",\n \"i + 1] ... END odd : CASE ... WHEN vColumn = argv[2\",\n \"= \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try:\",\n \"0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition +=\",\n \"optional If the function has two arguments (example, power or mod), 'x' represents\",\n \"nb, [], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems +=\",\n \"dtype, [str])]) try: query = \\\"SELECT {}::{} AS {} FROM {} WHERE {}\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns\",\n \"-------- vDataFrame.donut : Draws the donut chart of the vColumn based on an\",\n \"evaluate the approximate density function. Increasing this parameter will increase the precision but\",\n \"look like: even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2\",\n \"to True, the approximate median is returned. By setting this parameter to False,\",\n \"\\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1, close_l = \\\"<=\\\",\",\n \"steps different than 1.\\\" ) index_stop = index.stop index_start = index.start if not\",\n \"from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs):\",\n \"[sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])]\",\n \"else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and (val == None):\",\n \"MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try:\",\n \"] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias,\",\n \"the 3rd. end_date: str / date, optional Input End Date. For example, time\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes\",\n \"normalize by grouping by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning)\",\n \"\\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\\",\n \": trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube root\",\n \"Also -------- vDataFrame.isin : Looks if some specific records are in the vDataFrame.\",\n \"use when the parameter method is set to 'cat_stats'. Returns ------- tablesample An\",\n \"---# def plot( self, ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime,\",\n \"[ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if\",\n \"COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS\",\n \"/ # ____________ ______ # / __ `\\\\ / / # | \\\\/\",\n \"{} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\",\",\n \"be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See\",\n \"or equal to 2.\\\" ) assert len(breaks) == len(labels) + 1 or not\",\n \"vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"# ---# def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces\",\n \"Parameters ---------- method: str, optional The describe method. auto : Sets the method\",\n \"Parameters ---------- *args / **kwargs Any optional parameter to pass to the geopandas\",\n \"Returns True if the vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\",\",\n \"of a division operation pow : number raised to the power of another\",\n \"self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is\",\n \"1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when\",\n \"= [elem for elem in self.transformations] total = self.count() if method not in\",\n \"variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number of\",\n \"int(nbins))) assert nb != 0, Exception( \\\"Not enough values to compute the Equal\",\n \"the DB version you are using. Returns ------- tablesample An object containing the\",\n \"a copy will be created using the input Name. Returns ------- vDataFrame self.parent\",\n \"BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({})\",\n \"regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn.\",\n \"by: list = [], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing\",\n \"True, the record will be sliced using the floor of the slicing instead\",\n \"not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix =\",\n \"self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"\\\"\\\", max_cardinality: int = 6, h: float = 0, pie_type: str = \\\"auto\\\",\",\n \"{} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else\",\n \"in by]) ) if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) +\",\n \"testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the\",\n \"method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max\",\n \"\\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\\",\n \"bool, optional If set to True, draw an Area Plot. step: bool, optional\",\n \"logarithm log : logarithm log10 : base 10 logarithm mod : remainder of\",\n \"{}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", )\",\n \"--------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name: str\",\n \") self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot\",\n \"must be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat\",\n \"if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\",\",\n \"!\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool =\",\n \"== \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must be greater or\",\n \"( self.isnum() and method == \\\"smart\\\" ): n = len(result) trans = \\\"(CASE\",\n \"be slower if the vDataFrame has been transformed multiple times, so it's better\",\n \"{}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\"\",\n \"transformations. If the vDataFrame represents the entire relation, a vColumn can be seen\",\n \"self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on\",\n \"offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit)\",\n \"The integer k of the 'topk' method. new_category: str, optional The name of\",\n \"= 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({})\",\n \"applied to the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info ) )\",\n \"AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"OR CONDITIONS OF ANY KIND, either express or implied. # See the License\",\n \"average median : median min : minimum mode : most occurent element percent\",\n \"|| '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem\",\n \"mad != 0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad)\",\n \"'{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value: str =\",\n \"if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is\",\n \"\\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---#\",\n \"-------- vDataFrame.bar : Draws the Bar Chart of the input vColumns based on\",\n \"Parameters ---------- k: int, optional Number of most occurent elements to return. dropna:\",\n \"= self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True)\",\n \"Also -------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \\\"\\\"\\\"\",\n \"True, the Median will be drawn. ax: Matplotlib axes object, optional The axes\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches for\",\n \"avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif\",\n \"1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT {}, ord, non_events, events,\",\n \"final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\",\",\n \"spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds,\",\n \"normalized with the method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE) Table.\",\n \"None), ParameterError( \\\"At least 'lower' or 'upper' must have a numerical value\\\" )\",\n \"NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*)\",\n \"must be greater or equal to 2.\\\" ) assert len(breaks) == len(labels) +\",\n \"\\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\",\",\n \"\\\"percent\\\": [float(round(item[2], 3)) for item in result], } return tablesample(values) # ---# def\",\n \"0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method =\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth,\",\n \"/ NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query,\",\n \"idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search(\",\n \"cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"\\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\\",\n \"customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"),\",\n \"val == None: warning_message = \\\"The vColumn {} has no mode (only missing\",\n \"using the floor of the slicing instead of the ceiling. Returns ------- vDataFrame\",\n \"\\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by:\",\n \"Modules # # Standard Python Modules import math, re, decimal, warnings, datetime from\",\n \"object \\\"\\\"\\\" columns = [self.alias] check = True if len(args) > 0: column\",\n \"Focus or one of its affiliates. # Licensed under the Apache License, Version\",\n \"float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"to cut the vColumn. labels: list, optional Labels used to name the new\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the lower\",\n \"\\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"a numerical value\\\" ) lower_when = ( \\\"WHEN {} < {} THEN {}\",\n \"the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int =\",\n \"# ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the\",\n \"parameter to False, the function's performance can drastically decrease. Returns ------- int vColumn\",\n \"the function's performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate\",\n \"For example, it can be 'minute' 'hour'... start: bool, optional If set to\",\n \"p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def\",\n \"avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER\",\n \") ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent #\",\n \"[\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\",\",\n \"using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the\",\n \"of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority\",\n \"WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} >\",\n \"slower if the vDataFrame has been transformed multiple times, so it's better practice\",\n \"kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not\",\n \"else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\",\",\n \"\\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1]\",\n \"# # |_ |~) _ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_||\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule. Parameters\",\n \"to normalize by grouping by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message,\",\n \"return to_tablesample(query, title=title) # ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts\",\n \"\\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/\",\n \"self.isnum(), self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\",\",\n \"elem[2] if elem[2] != None else \\\"NULL\\\", ) for elem in result if\",\n \"numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical\",\n \"method.lower() if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema):\",\n \"See Also -------- vDataFrame[].date_part : Extracts a specific TS field from the vColumn.\",\n \"vColumn by the input element. Parameters ---------- x: float Input number. Returns -------\",\n \"---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float\",\n \"List of the different records. For example, to check if Badr and Fouad\",\n \"be computed. pie_type: str, optional The type of pie chart. auto : Regular\",\n \"not (dropna) and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter\",\n \"), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name\",\n \"max_cardinality: int, optional Maximum number of the vColumn distinct elements to be used\",\n \"sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] =\",\n \"Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See\",\n \"width bins. smart : Uses the Random Forest on a response column to\",\n \"argv[2 * i + 1] ... END odd : CASE ... WHEN vColumn\",\n \"+ 5). of: str, optional The vColumn to use to compute the aggregation.\",\n \"even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i\",\n \"self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding.\",\n \"using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]),\",\n \"TS. start_date: str / date, optional Input Start Date. For example, time =\",\n \"0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0,\",\n \"= self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't\",\n \"VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast\",\n \"% len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins,\",\n \"a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to\",\n \"self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query\",\n \"Interval width of the vColumns 1 and 2 bars. It is only valid\",\n \"vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category is date.\",\n \"1 ) result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random\",\n \"record is greater than the threshold, it will be considered as an outlier.\",\n \"mode (most occurent element). 0ifnull : 0 when the vColumn is null, 1\",\n \"vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower,\",\n \"code. Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if it is\",\n \"warnings, datetime from collections.abc import Iterable from typing import Union # VerticaPy Modules\",\n \"Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also --------\",\n \"int(nbins): nth_elems += [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format(\",\n \"elif method == \\\"minmax\\\": if n == 0: nullifzero = 0 cmin, cmax\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]:\",\n \"method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message\",\n \".values[self.alias] ) result = [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\",\",\n \"float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title =\",\n \"else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in copy_trans]\",\n \"the vDataFrame. Dropping a vColumn means simply not selecting it in the final\",\n \"method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\":\",\n \"self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS\",\n \"False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn.\",\n \"\\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] =\",\n \"- ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution\",\n \"vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns\",\n \"[self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) )\",\n \"\\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, },\",\n \"float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters\",\n \"if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {} >\",\n \"and do not apply it. This parameter is very useful for testing to\",\n \"float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider\",\n \"non-missing elements cvar : conditional value at risk dtype : vColumn type iqr\",\n \"'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date)\",\n \"predictive power of an independent variable in relation to the dependent variable. Parameters\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a\",\n \"freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1 / 3)]\",\n \"Copy]: A copy of the vColumn {} named {} was added to the\",\n \"The aggregations used are the median and two input quantiles. Parameters ---------- ts:\",\n \"def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the\",\n \"the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\"\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self):\",\n \"True, draw a Step Plot. ax: Matplotlib axes object, optional The axes to\",\n \"result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {},\",\n \"from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)\",\n \"\\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\\",\n \"the vColumn using 'product'. Returns ------- float product See Also -------- vDataFrame.aggregate :\",\n \"The new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy :\",\n \"of parameter 'breaks' must be greater or equal to 2.\\\" ) assert len(breaks)\",\n \"= \\\"auto\\\", expr: str = \\\"\\\", by: list = [], order_by: list =\",\n \"WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE {}\",\n \"alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ]\",\n \"'{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self, n: int): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"xmax = self.max() else: xmin, xmax = xlim custom_lines = [] columns =\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"it in the final generated SQL code. Note: Dropping a vColumn can make\",\n \"= self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail\",\n \"self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if\",\n \"be > 1) k: int, optional The integer k of the 'topk' method.\",\n \"was deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self,\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also --------\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by: str,\",\n \"trans else: self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem]\",\n \"return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn\",\n \"{}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return\",\n \"vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1 (1\",\n \"OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events /\",\n \"int / float / text / binary / spatial / uuid / undefined\",\n \"p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the\",\n \"val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"(only if the vColumn type is date like). The vColumn will be transformed.\",\n \"mad) else: final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad),\",\n \"FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias,\",\n \"the vColumn using 'sem' (standard error of mean). Returns ------- float sem See\",\n \"unique category. h: float, optional The interval size to convert to use to\",\n \"difference between the max and the min sem : standard error of the\",\n \"the lower bound itself and the values higher than the upper bound to\",\n \"vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality )\",\n \"self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr +=\",\n \"--------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ---------- n: int,\",\n \"Returns ------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"offset=-1) # ---# def topk(self, k: int = -1, dropna: bool = True):\",\n \"field to extract. It must be one of the following: CENTURY / DAY\",\n \"is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF\",\n \"# limitations under the License. # # |_ |~) _ _| _ /~\\\\\",\n \"self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if\",\n \"raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total > 0: try: if\",\n \"self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1)\",\n \"mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent See Also --------\",\n \"( \\\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}' END)\\\".format(\",\n \"be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat =\",\n \"of the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values\",\n \"digits to keep after the comma. Returns ------- vDataFrame self.parent See Also --------\",\n \"(byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import\",\n \"\\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy is a Python library\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] #\",\n \"{}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {},\",\n \"\\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular\",\n \"0 and 1 that represents the quantile. For example: 0.25 represents Q1. approx:\",\n \"int/float, optional If the function has two arguments (example, power or mod), 'x'\",\n \"{} AS {} FROM {} WHERE {} IS NOT NULL GROUP BY {}\",\n \"elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample\",\n \"x GROUP BY 1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT {},\",\n \"threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP\",\n \"column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(),\",\n \"vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count,\",\n \"to the vColumn. Parameters ---------- func: str Function to use to transform the\",\n \"to normalize. zscore : Normalization using the Z-Score (avg and std). (x -\",\n \"the bar chart of the vColumn based on an aggregation. Parameters ---------- method:\",\n \"case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name,\",\n \"this method when first preparing your data. Parameters ---------- new_name: str The new\",\n \"- vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 *\",\n \"in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast =\",\n \"= 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END\",\n \"|| '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT\",\n \"is date, False otherwise. Returns ------- bool True if the vColumn category is\",\n \"= self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features\",\n \"vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def\",\n \"Parameters ---------- threshold: float, optional Uses the Gaussian distribution to identify outliers. After\",\n \"+ [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If\",\n \"elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing\",\n \"# ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression\",\n \"stores all user transformations. If the vDataFrame represents the entire relation, a vColumn\",\n \"- 1], result[i] ) trans += \\\" ELSE NULL END)\\\" trans = (trans,\",\n \"you'll be able to solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements)\",\n \"the vColumn using 'median'. Parameters ---------- approx: bool, optional If set to True,\",\n \"Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table )\",\n \"int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response: str\",\n \"if (method == \\\"median\\\") else \\\"AVG\\\" if by == []: if fun ==\",\n \"else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {}\",\n \"'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) #\",\n \"number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"h = self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins\",\n \"'{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\":\",\n \"the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\"))\",\n \"\\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\":\",\n \"AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table\",\n \"schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\")\",\n \"to convert the vColumn. If this parameter is equal to 0, an optimised\",\n \"\\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]),\",\n \"sum : Sum of the vColumn 'of'. q% : q Quantile of the\",\n \"{}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except:\",\n \"for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor\",\n \"{}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord)\",\n \"transformations, str : List of the different transformations. \\\"\\\"\\\" # # Special Methods\",\n \"str Regular expression to replace. value: str, optional New value. Returns ------- vDataFrame\",\n \"{}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] !=\",\n \": value up to the next whole number cos : trigonometric cosine cosh\",\n \"remainder of a division operation pow : number raised to the power of\",\n \"(example, power or mod), 'x' represents the second argument. Returns ------- vDataFrame self.parent\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique...\",\n \"columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using a mean encoding\",\n \"] if method != \\\"robust_zscore\\\": max_floor = 0 for elem in by: if\",\n \"by the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns -------\",\n \"impute the missing values. auto : Mean for the numerical and Mode for\",\n \"sine atan : trigonometric inverse tangent cbrt : cube root ceil : value\",\n \"{}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() )\",\n \"Any optional parameter to pass to the geopandas plot function. For more information,\",\n \"\\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float):\",\n \"copy of the vColumn {} named {} was added to the vDataFrame.\\\".format( self.alias,\",\n \"of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int\",\n \"in each of the vColumn records. vDataFrame[].str_count : Computes the number of matches\",\n \"optional If set to True, the approximate quantile is returned. By setting this\",\n \"# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #\",\n \"occur, and other statistical information. Parameters ---------- k: int, optional Number of most\",\n \"expression generated will look like: even: CASE ... WHEN vColumn = argv[2 *\",\n \"self, by: str = \\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\",\",\n \"model parameters used to compute the best splits when 'method' is set to\",\n \"self.min()) * 1.01 / nbins if h > 0.01: h = round(h, 2)\",\n \"Returns the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def\",\n \"self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median\",\n \": sum std : standard deviation topk : kth most occurent element (ex:\",\n \"if h > 0.01: h = round(h, 2) elif h > 0.0001: h\",\n \"\\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by] for elem in all_partition:\",\n \"= aggregate # ---# def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\"\",\n \"for processing, VerticaPy brings the logic to the data. # # # Modules\",\n \": Uses popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold\",\n \"\\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05,\",\n \"a vColumn can be seen as one column of that relation. vColumns simplify\",\n \"'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception\",\n \"float])]) query = \\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER\",\n \"right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input\",\n \"the new vDataFrame of the search. Parameters ---------- val: list List of the\",\n \"\\\"Can not normalize {} using a Z-Score - The Standard Deviation is null\",\n \"(unit: b). Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of,\",\n \"vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\"\",\n \"geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args /\",\n \"BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads\",\n \"width of the bar. If empty, an optimized h will be computed. pie_type:\",\n \"DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() )\",\n \"-> x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If\",\n \"limit: int = 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part\",\n \"result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table =\",\n \"{} has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"Slices the vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\"))\",\n \"by the NULL value. winsorize : Clips the vColumn using as lower bound\",\n \"vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self,\",\n \"[], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn.\",\n \"{}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for item in query_result]\",\n \": hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent tanh\",\n \"case of discretization using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response'\",\n \"RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model\",\n \"sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total\",\n \"case of discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans =\",\n \"5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int,\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]:\",\n \"---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float\",\n \"method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method\",\n \"= False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies\",\n \"| |(_(_|| \\\\/ # / # VerticaPy is a Python library with scikit-like\",\n \"the spider plot of the input vColumn based on an aggregation. Parameters ----------\",\n \"{} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else\",\n \"/ DAY / DECADE / DOQ / DOW / DOY / EPOCH /\",\n \"kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10)\",\n \"Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum number of nbins\",\n \") elif self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter\",\n \"vColumn using an input 'quantile'. Parameters ---------- x: float A float between 0\",\n \"len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor):\",\n \"kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self,\",\n \"usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage\",\n \"10. response: str, optional Response vColumn when method is set to 'smart'. return_enum_trans:\",\n \"\\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\",\",\n \"upper ZScores. threshold: float, optional Uses the Gaussian distribution to define the outliers.\",\n \"self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception\",\n \"tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \\\"\\\"\\\"\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the\",\n \"f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE\",\n \"\\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor = 0 for elem in\",\n \"elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ]\",\n \"percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"length: int Slice size. unit: str, optional Slice size unit. For example, it\",\n \"(\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date,\",\n \"= (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of\",\n \"RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random\",\n \"# | \\\\/ / / / # |______ / / / # |____/\",\n \"ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality:\",\n \"list, optional List of the different categories to consider when drawing the box\",\n \"vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See\",\n \"input method. Parameters ---------- method: str, optional The describe method. auto : Sets\",\n \"!= None) or (upper != None), ParameterError( \\\"At least 'lower' or 'upper' must\",\n \"* i] THEN argv[2 * i + 1] ... ELSE argv[n] END Returns\",\n \"\\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\":\",\n \"= \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else:\",\n \"int/float/tuple, optional Interval width of the vColumns 1 and 2 bars. It is\",\n \"to use to impute the missing values. auto : Mean for the numerical\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the\",\n \"{} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent\",\n \"[dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins,\",\n \"\\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format(\",\n \"elem in result if elem[2] != None ] ), ) executeSQL( \\\"SELECT {},\",\n \"pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type == \\\"donut\\\"\",\n \"100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q: tuple =\",\n \"__setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # # ---# def\",\n \"self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] =\",\n \"0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"set to 'cat_stats'. Returns ------- tablesample An object containing the result. For more\",\n \"h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\",\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str\",\n \") count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max( float(vColumn_max -\",\n \"column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\"\",\n \"\\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in\",\n \"the lower and upper ZScores. threshold: float, optional Uses the Gaussian distribution to\",\n \"\\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category,\",\n \"List of the different aggregation. aad : average absolute deviation approx_unique : approximative\",\n \"time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date,\",\n \"for the categorical vColumns. bfill : Back Propagation of the next element (Constant\",\n \"Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n\",\n \"for item in executeSQL( query=query, title=\\\"Computing the average of the {}'s lower and\",\n \"[bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by)\",\n \"a list of at least one element to use to order the data\\\"\",\n \"/ # ______ / / # \\\\ / / / # \\\\ /\",\n \"absolute deviation approx_unique : approximative cardinality count : number of non-missing elements cvar\",\n \"close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r =\",\n \"\\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int\",\n \"upper bound to the upper bound itself. Parameters ---------- lower: float, optional Lower\",\n \"expr: str, optional SQL expression. by: list, optional vColumns used in the partition.\",\n \"optional If set to True, draw an Area Plot. step: bool, optional If\",\n \"limits of the current axes. ax: Matplotlib axes object, optional The axes to\",\n \"conducting # data science projects on data stored in Vertica, taking advantage Vertica’s\",\n \"] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev,\",\n \"colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel,\",\n \"from the vDataFrame. Dropping a vColumn means simply not selecting it in the\",\n \"object, optional The axes to plot on. **style_kwds Any optional parameter to pass\",\n \"parameter to False, the function's performance can drastically decrease. Returns ------- float/str median\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature by\",\n \"plot. gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel.\",\n \"approx: bool, optional If set to True, the approximate quantile is returned. By\",\n \"result = executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", )\",\n \"valid if the vColumns are numerical. Optimized h will be computed if the\",\n \"vDataFrame.astype : Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])])\",\n \"\\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self, approx: bool\",\n \"self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\"\",\n \"x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not\",\n \"vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def\",\n \": Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075\",\n \"only if the parameter 'by' is empty\\\\nIf you want to normalize by grouping\",\n \"history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns\",\n \"the input vColumns using the input method. Parameters ---------- method: str, optional Method\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"\\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ #\",\n \"only categorical aggregations during the computation. cat_stats : Computes statistics of a numerical\",\n \") else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\",\",\n \"supports the # entire data science life cycle, uses a ‘pipeline’ mechanism to\",\n \"If the vColumn type is date like (date, datetime ...), the parameter 'x'\",\n \"result[i - 1], result[i] ) trans += \\\" ELSE NULL END)\\\" trans =\",\n \"(None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the\",\n \"bar. If empty, an optimized h will be computed. ax: Matplotlib axes object,\",\n \"the vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations\",\n \"absolute value of the record is greater than the threshold it will be\",\n \"Parameters ---------- func: list List of the different aggregation. aad : average absolute\",\n \"numcol, [str]), ] ) method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol),\",\n \"depending on the input method. Parameters ---------- method: str, optional The describe method.\",\n \"in each of the vColumn records by an input value. vDataFrame[].str_slice : Slices\",\n \"else: final_transformation = [ ( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\",\",\n \"the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if\",\n \"THEN argv[2 * i + 1] ... ELSE argv[n] END Returns ------- vDataFrame\",\n \"------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"n == 1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {}\",\n \"donut chart of the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str):\",\n \"op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label =\",\n \"dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns -------\",\n \"{})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem'\",\n \"# ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the\",\n \"{}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] )\",\n \"WOE & IV of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title)\",\n \"Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR\",\n \"the vColumn using 'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate :\",\n \"int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {} > {} THEN {}\",\n \") try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except:\",\n \"+ {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ),\",\n \"self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing\",\n \"method: dict, optional Method to use to impute the missing values. auto :\",\n \"= executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result =\",\n \"def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type.\",\n \"\\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method\",\n \"bool, optional Uses numbers as suffix instead of the vColumns categories. Returns -------\",\n \"val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in the\",\n \"float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k < 1) else \\\"LIMIT\",\n \"ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\"\",\n \"= \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool =\",\n \"list = [], include_lowest: bool = True, right: bool = True, ): \\\"\\\"\\\"\",\n \"\\\"\\\", area: bool = False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top =\",\n \"Parameters ---------- method: str, optional Method to use to compute the optimal h.\",\n \"[\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available for categorical variables.\\\" )\",\n \"conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = (\",\n \"if the vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn\",\n \"self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass\",\n \"will be picked or computed) h: float, optional Interval width of the bar.\",\n \"= round(h, 4) elif h > 0.000001: h = round(h, 6) if self.category()\",\n \"h: float = 0, max_cardinality: int = 8, cat_priority: list = [], ax=None,\",\n \"float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input\",\n \"gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in\",\n \"use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins,\",\n \"YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn\",\n \"ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the\",\n \"# /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\\",\n \"density : Percentage of the distribution. mean : Average of the vColumn 'of'.\",\n \"parent, alias, [elem for elem in transformations], ) self.catalog = { \\\"cov\\\": {},\",\n \"using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model\",\n \"\\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans =\",\n \"100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {}\",\n \"set to True, the approximate cardinality is returned. By setting this parameter to\",\n \"100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the vColumn {} using\",\n \"max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor =\",\n \"* int(nbins): nth_elems += [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN\",\n \"{} THEN {} WHEN {} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\",\",\n \"the parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns -------\",\n \"Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"= self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h,\",\n \"--------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns ------- int vColumn\",\n \"representing the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will\",\n \"(result) else result[0][0] if not (dropna): n = \\\"\\\" if (n == 1)\",\n \"is only valid if the vColumns are numerical. Optimized h will be computed\",\n \"number cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent\",\n \"cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp : exponential function\",\n \"isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index\",\n \"\\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"]\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func 'x\",\n \"return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else\",\n \"the logic to the data. # # # Modules # # Standard Python\",\n \"executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False,\",\n \"regular width bins. smart : Uses the Random Forest on a response column\",\n \"), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__()\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY\",\n \"self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap\",\n \"See Also -------- vDataFrame[].tail : Returns the a part of the vColumn. \\\"\\\"\\\"\",\n \"tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be\",\n \"title=\\\"Computing the top{} categories of {}.\\\".format( k if k > 0 else \\\"\\\",\",\n \"bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"---------- n: int Number of digits to keep after the comma. Returns -------\",\n \"\\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\",\",\n \"{}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha ==\",\n \"import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) )\",\n \"new_category: str, optional The name of the merging category when using the 'topk'\",\n \"vColumn. The function variable must be composed of two flower brackets {}. For\",\n \"[name] conj = \\\"s were \\\" if len(all_new_features) > 1 else \\\" was\",\n \"# ---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float = 4.0,\",\n \"OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM\",\n \"for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in\",\n \"{\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest with 20 trees and\",\n \"based on an aggregation. Parameters ---------- method: str, optional The method to use\",\n \"cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot\",\n \"self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS\",\n \"check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self):\",\n \"+= [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def\",\n \"\\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum()\",\n \"Also -------- vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit,\",\n \"self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs): from\",\n \"prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix:\",\n \"new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50):\",\n \"mode(self, dropna: bool = False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"{}. For example to apply the function: x -> x^2 + 2 use\",\n \"AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x\",\n \"DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field:\",\n \"{}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] !=\",\n \"{} WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1\",\n \"bar( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int =\",\n \"The vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns -------\",\n \"assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals to\",\n \"= [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\":\",\n \"-------- vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum :\",\n \"one of the following: date / int / float / text / binary\",\n \"to 'cat_stats'. Returns ------- tablesample An object containing the result. For more information,\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else:\",\n \"prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\")\",\n \"return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val # #\",\n \"vColumn 'of'. sum : Sum of the vColumn 'of'. q% : q Quantile\",\n \"ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE\",\n \"str vColumn alias. transformations: list, optional List of the different transformations. Each transformation\",\n \"return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category\",\n \"---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for\",\n \") else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format(\",\n \"trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\",\",\n \"to True, the approximate quantile is returned. By setting this parameter to False,\",\n \"must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat\",\n \"---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute\",\n \"+ 1) and (method != \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\")\",\n \"vColumn and creating a copy with the specified name. \\\\u26A0 Warning : SQL\",\n \"Also -------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] #\",\n \"(No h will be picked or computed) ax: Matplotlib axes object, optional The\",\n \"check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column\",\n \"computed if the parameter is empty or invalid. max_cardinality: int, optional Maximum number\",\n \"ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result\",\n \"AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS\",\n \"method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT\",\n \"elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\":\",\n \"part of the vColumn (delimited by an offset and a limit). Parameters ----------\",\n \"USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"parameter. alpha: float, optional Number representing the outliers threshold. Values lesser than quantile(alpha)\",\n \"when using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna :\",\n \"_| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________\",\n \"down to the next whole number ln : natural logarithm log : logarithm\",\n \"def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis\",\n \"work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if n\",\n \"= \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def\",\n \"--------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str,\",\n \"self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax,\",\n \"data science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation\",\n \"float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result\",\n \"input vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval :\",\n \"'{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions)\",\n \"k >= 2, ParameterError( \\\"Parameter 'k' must be greater or equals to 2\",\n \"as upper bound quantile(1-alpha) if 'use_threshold' is set to False else the lower\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0]\",\n \"self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to the vColumn {}\\\\n{} feature{}created:\",\n \"+= [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] =\",\n \"if the response is numerical (except ints and bools), a RF Classifier otherwise.\",\n \": Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 *\",\n \": Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with\",\n \"dropna, [bool])]) topk = \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna\",\n \"\\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/\",\n \"vColumn using the input list. Parameters ---------- breaks: list List of values used\",\n \"raised to the power of another number round : rounds a value to\",\n \"\\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\\",\n \": Applies a function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks,\",\n \"using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])])\",\n \": Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna,\",\n \"elif h > 0.0001: h = round(h, 4) elif h > 0.000001: h\",\n \"= sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return\",\n \"= None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / (\",\n \"each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in\",\n \"from the vColumn (only if the vColumn type is date like). The vColumn\",\n \"str The field to extract. It must be one of the following: CENTURY\",\n \"is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during the\",\n \"__ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\\",\n \"Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self):\",\n \"dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query\",\n \"built-in analytics and machine learning features. It supports the # entire data science\",\n \"= 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%',\",\n \"optional If set to True, the information will be stored in the vDataFrame\",\n \"self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message = \\\"Can not normalize\",\n \"must have a numerical value\\\" ) lower_when = ( \\\"WHEN {} < {}\",\n \"cat = [], self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\"\",\n \"vColumn. If this parameter is equal to 0, an optimised interval will be\",\n \"NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query, )\",\n \"include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l =\",\n \"Regular expression to replace. value: str, optional New value. Returns ------- vDataFrame self.parent\",\n \"+ \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn\",\n \"a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The\",\n \"/ {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h,\",\n \"MIN and the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"] ) donut = True if pie_type == \\\"donut\\\" else False rose =\",\n \"\\\".join([quote_ident(column) for column in by]) ) if (by) else \\\"\\\" ) order_by_ts =\",\n \"up to the next whole number cos : trigonometric cosine cosh : hyperbolic\",\n \"is numerical, False otherwise. Returns ------- bool True if the vColumn is numerical.\",\n \"\\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]),\",\n \"'03-11-1993' will filter the data when 'ts' is greater than November 1993 the\",\n \"method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method\",\n \"-------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total =\",\n \"optional Cardinality threshold to use to determine if the vColumn will be considered\",\n \"computed. h: float, optional Interval width of the bar. If empty, an optimized\",\n \"Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check = True if len(args) >\",\n \": value down to the next whole number ln : natural logarithm log\",\n \"or numerical. by: str, optional vColumn to use to partition the TS. start_date:\",\n \"name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") )\",\n \"1], result[i], result[i - 1], result[i] ) trans += \\\" ELSE NULL END)\\\"\",\n \"= self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count()\",\n \"Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y =\",\n \"return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def\",\n \"utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of the vColumn.\",\n \"str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} )\",\n \"p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def fillna( self, val=None,\",\n \"FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn\",\n \"outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with 0\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result =\",\n \"2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) /\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) #\",\n \"expression in each record of the vColumn. vDataFrame[].str_replace : Replaces the regular expression\",\n \"---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---#\",\n \"threshold: float, optional Uses the Gaussian distribution to identify outliers. After normalizing the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns ------- float\",\n \"'[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i] ) trans\",\n \"distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)):\",\n \"vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate():\",\n \"Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float A float\",\n \"else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn\",\n \") ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of\",\n \"vDataFrame has been transformed multiple times, so it's better practice to use this\",\n \"input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply(\",\n \"self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}'\",\n \"of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable\",\n \") new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, )\",\n \"max_cardinality ) if distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others',\",\n \"index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category()\",\n \"or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category,\",\n \"elements. density : Percentage of the distribution. mean : Average of the vColumn\",\n \"({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product\",\n \"PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5)\",\n \"alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of\",\n \"self.alias, dtype ) ) return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe\",\n \"in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format(\",\n \"int, optional Number of elements to display. offset: int, optional Number of elements\",\n \"[ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"{}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER\",\n \"one vColumn can only have one parent. catalog: dict, optional Catalog where each\",\n \"COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean,\",\n \"(\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method ==\",\n \"the absolute value of the record is greater than the threshold it will\",\n \"Maximum number of the vColumn distinct elements to be used as categorical (No\",\n \"{} as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding\",\n \"self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation =\",\n \"self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"median). It can also be a cutomized aggregation (ex: AVG(column1) + 5). of:\",\n \"If set to True, the approximate median is returned. By setting this parameter\",\n \"area: bool, optional If set to True, draw an Area Plot. step: bool,\",\n \"result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"1) return best_h # ---# def nunique(self, approx: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \") result = executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\",\",\n \"DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in\",\n \"= '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query +\",\n \"if mad != 0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med,\",\n \"func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {}\",\n \"one parent. catalog: dict, optional Catalog where each key corresponds to an aggregation.\",\n \"[] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx\",\n \"result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER\",\n \"represent the number of seconds, otherwise it will represent a number. Returns -------\",\n \"= kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a\",\n \"min) / (max - min) by: list, optional vColumns used in the partition.\",\n \"/ _ __|_. _ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/ #\",\n \"def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element.\",\n \"assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y)\",\n \"({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM\",\n \"vColumns, cast the other types to varchar. same_freq : Computes bins with the\",\n \"offers beautiful graphical options. # # VerticaPy aims to do all of the\",\n \"equals to 2 in case of discretization using the method 'same_freq'\\\" ) count\",\n \"* 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str, q: tuple\",\n \"(\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of)\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of\",\n \"y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func: list List\",\n \"def density( self, by: str = \\\"\\\", bandwidth: float = 1.0, kernel: str\",\n \"add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent\",\n \"between 0 and 1 that represents the quantile. For example: 0.25 represents Q1.\",\n \") values = { \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for\",\n \"self.parent # ---# def median( self, approx: bool = True, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"regular expression matches in each of the vColumn record by an input value.\",\n \"the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in\",\n \"---# def describe( self, method: str = \\\"auto\\\", max_cardinality: int = 6, numcol:\",\n \"greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also --------\",\n \"numcol: str, optional Numerical vColumn to use when the parameter method is set\",\n \"assert (lower != None) or (upper != None), ParameterError( \\\"At least 'lower' or\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h,\",\n \"method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result index\",\n \"query, nth_elems = nb, [], [] while total < int(float(count / int(nbins))) *\",\n \"None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query\",\n \"function variable must be composed of two flower brackets {}. For example to\",\n \"[ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\",\",\n \"else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", ) for elem in\",\n \"item[0] for item in executeSQL( query=query, title=\\\"Computing the average of the {}'s lower\",\n \"= True if pie_type == \\\"donut\\\" else False rose = True if pie_type\",\n \"vColumn. The aggregations used are the median and two input quantiles. Parameters ----------\",\n \"be picked or computed) ax: Matplotlib axes object, optional The axes to plot\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\")\",\n \"from collections.abc import Iterable from typing import Union # VerticaPy Modules import verticapy\",\n \"mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN\",\n \"of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \\\"\",\n \"the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query =\",\n \"occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class\",\n \"if total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj))\",\n \"will be picked or computed) nbins: int, optional Number of bins. If empty,\",\n \"hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit:\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot\",\n \"else: lp, rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT\",\n \"= ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower,\",\n \"** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif\",\n \"{} || ';' || (FLOOR({} / {}) * {} + {}{}) || ']'\\\".format(\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as percents.\",\n \"[by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\", method, [\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\",\",\n \"ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"]\",\n \"def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of\",\n \"tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn.\",\n \"\\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else\",\n \"vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters\",\n \"of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"]\",\n \"offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample(\",\n \"\\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None,\",\n \"to the input vColumns. vDataFrame.applymap : Applies a function to all the vColumns.\",\n \"= [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a\",\n \"k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)),\",\n \"Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n\",\n \"number of distinct elements for vColumns 1 and 2 to be used as\",\n \"True if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned by the\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self,\",\n \"It must be one of the following: CENTURY / DAY / DECADE /\",\n \"the median). It can also be a cutomized aggregation (ex: AVG(column1) + 5).\",\n \"= 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an\",\n \"pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart\",\n \"{}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {},\",\n \"method=\\\"fetchall\\\", ) top = None if not (result) else result[0][0] if not (dropna):\",\n \"how often they occur, and other statistical information. Parameters ---------- k: int, optional\",\n \"item in sublist] # ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the\",\n \"the learning and scoring phases. xlim: tuple, optional Set the x limits of\",\n \"\\\"[Add Copy]: A copy of the vColumn {} named {} was added to\",\n \"(isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method\",\n \"# ---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\",\",\n \"example, if n = 1 then this method will return the mode of\",\n \"start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a\",\n \"The function variable must be composed of two flower brackets {}. For example\",\n \"else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to\",\n \"of the vColumn. vDataFrame[].extract : Extracts the regular expression in each record of\",\n \"where each key corresponds to an aggregation. vColumns will memorize the already computed\",\n \"_ |_) # \\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy is\",\n \"q% : q quantile (ex: 50% for the median) prod : product range\",\n \"ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds,\",\n \"result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second',\",\n \"categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also\",\n \"(\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf\",\n \"Python Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable from\",\n \"\\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\":\",\n \"upper and lower outliers by their respective average. null : Replaces the outliers\",\n \"Rose chart. It can also be a cutomized aggregation (ex: AVG(column1) + 5).\",\n \"a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def\",\n \"Aggregates the vColumn using the input functions. Parameters ---------- func: list List of\",\n \"---# def mode(self, dropna: bool = False, n: int = 1): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"sqrt : arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent\",\n \"of digits to keep after the comma. Returns ------- vDataFrame self.parent See Also\",\n \"vDataFrame.bar : Draws the Bar Chart of the input vColumns based on an\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a user\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"# ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns\",\n \"can be seen as one column of that relation. vColumns simplify several processes\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new\",\n \"> 0.000001: h = round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h),\",\n \"{}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT {} FROM {}\",\n \"Parameters ---------- n: int Number of digits to keep after the comma. Returns\",\n \"by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC\",\n \"= \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE\",\n \") if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias]\",\n \"_verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias,\",\n \"method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h =\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if\",\n \"for the median) prod : product range : difference between the max and\",\n \"# ---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return\",\n \"extract. It must be one of the following: CENTURY / DAY / DECADE\",\n \"self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a time series\",\n \"result = [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\",\",\n \"The vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval width\",\n \"Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also --------\",\n \"\\\"SELECT {} AS {}, {} AS ord, {}::int AS {} FROM {}\\\".format( trans,\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def\",\n \"method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by]\",\n \"), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans:\",\n \"the vDataFrame has been transformed multiple times, so it's better practice to use\",\n \"Python object which that stores all user transformations. If the vDataFrame represents the\",\n \"( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name\",\n \"\\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS {} FROM {} WHERE\",\n \"vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the other types\",\n \"by transforming the values lesser than the lower bound to the lower bound\",\n \"FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in the\",\n \"ceil : value up to the next whole number cos : trigonometric cosine\",\n \"\\\"\\\" query, cat = [], self.distinct() if len(cat) == 1: lp, rp =\",\n \"'of'. q% : q Quantile of the vColumn 'of' (ex: 50% to get\",\n \">= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals to 2 in\",\n \"[int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"warning_message = \\\"The vColumn {} has no mode (only missing values).\\\\nNothing was filled.\\\".format(\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 *\",\n \"abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns\",\n \"converted to {}\\\".format( e, self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\"\",\n \"--------------------------------------------------------------------------- Extracts a specific TS field from the vColumn (only if the vColumn\",\n \"st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str = \\\"\\\",\",\n \"use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns categories. Returns\",\n \"input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule.\",\n \"been transformed multiple times, so it's better practice to use this method when\",\n \"a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name\",\n \"\\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if\",\n \"self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"[bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n =\",\n \"optional The bandwidth of the kernel. kernel: str, optional The method used for\",\n \"optional Number of most occurent elements to return. dropna: bool, optional If set\",\n \"not (dropna): n = \\\"\\\" if (n == 1) else str(int(n)) if isinstance(top,\",\n \"QueryError( \\\"{}\\\\nError when applying the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\",\",\n \"(PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The\",\n \"'{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), )\",\n \"slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part\",\n \"grouping by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self\",\n \"= '03-11-1993' will filter the data when 'ts' is lesser than November 1993\",\n \"cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of\",\n \"+ sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total #\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ----------\",\n \"def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the\",\n \"has been transformed multiple times, so it's better practice to use this method\",\n \"True if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True\",\n \"if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if\",\n \"method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold,\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])])\",\n \"{} can not be converted to {}\\\".format( e, self.alias, dtype ) ) #\",\n \": conditional value at risk dtype : vColumn type iqr : interquartile range\",\n \"Quantile of the vColumn 'of' (ex: 50% to get the median). It can\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies :\",\n \"k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\":\",\n \"vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new\",\n \"Parameters ---------- val: list List of the different records. For example, to check\",\n \"THEN argv[2 * i + 1] ... END odd : CASE ... WHEN\",\n \"bool, optional If set to True, the approximate quantile is returned. By setting\",\n \"max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func)\",\n \"catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent, alias, [elem\",\n \"2, ParameterError( \\\"Parameter 'k' must be greater or equals to 2 in case\",\n \"categorical (No h will be picked or computed) nbins: int, optional Number of\",\n \") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines\",\n \"and it returns the new vDataFrame of the search. Parameters ---------- val: list\",\n \"= \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1, close_l\",\n \"/ {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha\",\n \"elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv:\",\n \"{} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" )\",\n \"(\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if\",\n \"n): trans += \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\",\",\n \"phases. xlim: tuple, optional Set the x limits of the current axes. ax:\",\n \"---# def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest\",\n \"force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias)\",\n \") else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") #\",\n \"of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result for item in\",\n \"\\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower()\",\n \"will be created using the input Name. Returns ------- vDataFrame self.parent See Also\",\n \"\\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else:\",\n \"the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional Maximum\",\n \"spatial / uuid / undefined Returns ------- str vColumn category. See Also --------\",\n \"--------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than the lower bound\",\n \"type is date like (date, datetime ...), the parameter 'x' will represent the\",\n \"[ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]),\",\n \"for the specific language governing permissions and # limitations under the License. #\",\n \"--------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0]\",\n \"{} using the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---#\",\n \"def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns\",\n \"Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp =\",\n \"Returns True if the vColumn is boolean, False otherwise. Returns ------- bool True\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod =\",\n \"mad). (x - median) / (1.4826 * mad) minmax : Normalization using the\",\n \") values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and\",\n \"aggregations used are the median and two input quantiles. Parameters ---------- ts: str\",\n \"------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"!= \\\"robust_zscore\\\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor:\",\n \"use to transform the vColumn. abs : absolute value acos : trigonometric inverse\",\n \"max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name:\",\n \"\\\"It can be the result of using previously the method on the vColumn\",\n \"else: self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"product # ---# def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"A copy of the vColumn {} named {} was added to the vDataFrame.\\\".format(\",\n \"assert response_cat == [0, 1], TypeError( \\\"vColumn {} must be binary to use\",\n \") if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for\",\n \"---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average\",\n \"elements to skip. Returns ------- tablesample An object containing the result. For more\",\n \"to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1],\",\n \"name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must\",\n \"[ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int,\",\n \"aggregations could work if it is part of the DB version you are\",\n \"result if elem[1] != None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]),\",\n \"0, nbins: int = -1, k: int = 6, new_category: str = \\\"Others\\\",\",\n \"model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params()\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} *\",\n \"This parameter is used for testing purpose. Returns ------- vDataFrame self.parent See Also\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int,\",\n \"\\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels:\",\n \"most occurent elements, how often they occur, and other statistical information. Parameters ----------\",\n \"Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types( [\",\n \"Returns the k most occurent elements, how often they occur, and other statistical\",\n \"self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail #\",\n \"if it is used to compute other vColumns. Parameters ---------- add_history: bool, optional\",\n \"self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN {} > {} THEN\",\n \"\\\" if total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total,\",\n \"< 0: offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation. Parameters\",\n \"\\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans: bool = False,\",\n \"list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth,\",\n \"the vColumn using the mean encoding of a response. \\\"\\\"\\\" if self.category() in\",\n \"vColumn is boolean, False otherwise. Returns ------- bool True if the vColumn is\",\n \"self.category() == \\\"float\\\" else \\\"\\\" if index < 0: index += self.parent.shape()[0] query\",\n \"query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for\",\n \"the vColumn using the average of the response partitioned by the different vColumn\",\n \"# # __ __ ______ ______ __ __ __ __ __ __ __\",\n \"max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"= [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = (\",\n \"/ # |______ / / / # |____/ / / # _____________ /\",\n \"self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\",\",\n \"for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], } return\",\n \"the first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional\",\n \"---------- threshold: float, optional Uses the Gaussian distribution to identify outliers. After normalizing\",\n \"query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({})\",\n \"the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to pass\",\n \"the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \"1], [1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\")\",\n \"self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name)\",\n \"values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result,\",\n \"can make the vDataFrame \\\"heavier\\\" if it is used to compute other vColumns.\",\n \"[str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature\",\n \"(\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ),\",\n \"ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn DB\",\n \"/ TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr,\",\n \"in kwargs: query = \\\"SELECT {} AS {} FROM {} WHERE {} IS\",\n \"else \\\"\\\", stddev ) else: final_transformation = [ ( \\\"({} - {}) /\",\n \"'{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn must be numerical for\",\n \"computed) h: float, optional Interval width of the bar. If empty, an optimized\",\n \"} return tablesample(values) # ---# def value_counts(self, k: int = 30): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"float, optional Interval width of the bar. If empty, an optimized h will\",\n \"elem in result if elem[1] != None ] ), ) cmax = \\\"DECODE({},\",\n \"method: str = \\\"auto\\\", expr: str = \\\"\\\", by: list = [], order_by:\",\n \"elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\")\",\n \"(\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---#\",\n \"ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {}\",\n \"the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \"plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames\",\n \"> 0: warning_message = \\\"The method 'robust_zscore' is available only if the parameter\",\n \"[item[0] for item in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2],\",\n \"'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\" ) for k in\",\n \"category is date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\"\",\n \"vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by =\",\n \"NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n )\",\n \"in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"],\",\n \"alias: str, transformations: list = [], parent=None, catalog: dict = {} ): self.parent,\",\n \"float = 0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds,\",\n \"optional If set to True, the Median will be drawn. ax: Matplotlib axes\",\n \"\\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\")\",\n \"h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater or\",\n \"agg = aggregate # ---# def apply(self, func: str, copy_name: str = \\\"\\\"):\",\n \"optional If set to True, the approximate cardinality is returned. By setting this\",\n \"final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"bool, optional Uses the threshold instead of the 'alpha' parameter. alpha: float, optional\",\n \"Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total\",\n \"the input vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval\",\n \"the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"each key corresponds to an aggregation. vColumns will memorize the already computed aggregations\",\n \"popular numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use\",\n \"of its affiliates. # Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\",\n \"use to evaluate the approximate density function. Increasing this parameter will increase the\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, h: float = 0,\",\n \"rose = True if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of\",\n \"Parameters ---------- approx: bool, optional If set to True, the approximate cardinality is\",\n \"not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---#\",\n \"with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List\",\n \"bool = True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in\",\n \"vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} <\",\n \"datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]),\",\n \"= [], self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else:\",\n \"than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent\",\n \"{} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers(\",\n \"See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in each\",\n \"Encoding was applied to the vColumn {} using the following mapping:{}\\\".format( self.alias, text_info\",\n \"--------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of digits after\",\n \"self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"',\",\n \"Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]),\",\n \"to consider when drawing the box plot. The other categories will be filtered.\",\n \"fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY\",\n \"in result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__()\",\n \"For example, time = '03-11-1993' will filter the data when 'ts' is greater\",\n \"\\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx:\",\n \"self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() ==\",\n \"Parameters ---------- x: float If the vColumn type is date like (date, datetime\",\n \"vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\")\",\n \"in each of the vColumn records. vDataFrame[].extract : Extracts the regular expression in\",\n \"VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n\",\n \"casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts: str\",\n \"def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns -------\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try: result\",\n \"trees and a maximum depth of 10. response: str, optional Response vColumn when\",\n \"DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query\",\n \"a new category : 'Others'. cat_priority: list, optional List of the different categories\",\n \"\\\"]\\\" if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [\",\n \"the length of parameter 'labels' + 1 or parameter 'labels' must be empty.\\\"\",\n \"dict = {}, response: str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\"\",\n \"be generated. include_lowest: bool, optional If set to True, the lowest element of\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0]\",\n \"represents the entire relation, a vColumn can be seen as one column of\",\n \"+ result, } if ((is_date) and not (method == \\\"categorical\\\")) or ( method\",\n \"all_new_features += [name] conj = \\\"s were \\\" if len(all_new_features) > 1 else\",\n \"only works on numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError(\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by: str =\",\n \"donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str, by:\",\n \": Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode\",\n \"of Freedman Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR /\",\n \"sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem)\",\n \"= {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if\",\n \"columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\"\",\n \"FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format(\",\n \"result + [self.max()] elif method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter\",\n \"median : median. mode : mode (most occurent element). 0ifnull : 0 when\",\n \") query = \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE WHEN\",\n \"\\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\":\",\n \"AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4}\",\n \"Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y\",\n \"{} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE {}\",\n \"std robust_zscore : Normalization using the Robust Z-Score (median and mad). (x -\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is\",\n \"optional Number of elements to display. offset: int, optional Number of elements to\",\n \"\\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if\",\n \"missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using\",\n \"get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column)\",\n \"sine sinh : hyperbolic sine sqrt : arithmetic square root tan : trigonometric\",\n \"only have one parent. catalog: dict, optional Catalog where each key corresponds to\",\n \"vColumns. vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval : Evaluates\",\n \"input 'quantile'. Parameters ---------- x: float A float between 0 and 1 that\",\n \"and not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index,\",\n \"if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if\",\n \"expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter(\",\n \"\\\"\\\") ) ) # ---# def apply_fun(self, func: str, x: float = 2):\",\n \"str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str,\",\n \"least one element to use to order the data\\\" ) desc = \\\"\\\"\",\n \"return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad !=\",\n \"records. For example, to check if Badr and Fouad are in the vColumn.\",\n \"return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories\",\n \"'smart'. A RF Regressor will be trained if the response is numerical (except\",\n \"to plot on. **style_kwds Any optional parameter to pass to the Matplotlib functions.\",\n \"value. winsorize : Clips the vColumn using as lower bound quantile(alpha) and as\",\n \"False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn.\",\n \"\\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and (val == None): val\",\n \"cat_stats : Computes statistics of a numerical column for each vColumn category. In\",\n \"{}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column\",\n \"of discretization using the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can\",\n \"kth most occurent element density unique : cardinality (count distinct) var : variance\",\n \"bfill : Back Propagation of the next element (Constant Interpolation). ffill : Propagation\",\n \"= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e:\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an\",\n \"\\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun,\",\n \"--------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks: list List\",\n \"meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\",\",\n \"otherwise. Returns ------- bool True if the vColumn category is date. See Also\",\n \"= [], include_lowest: bool = True, right: bool = True, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"{}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format( self.alias,\",\n \"vDataFrame.donut : Draws the donut chart of the vColumn based on an aggregation.\",\n \"self.isnum() or self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\" ) if\",\n \"COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias,\",\n \"catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2,\",\n \"arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float,\",\n \"specified number of decimal places sign : arithmetic sign sin : trigonometric sine\",\n \"+ desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER\",\n \"str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True, alpha: float\",\n \"vColumn to use to partition the data. method: str, optional The method to\",\n \"vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the\",\n \"to identify outliers. After normalizing the data (Z-Score), if the absolute value of\",\n \"of the vColumn based on an aggregation. Parameters ---------- method: str, optional The\",\n \"number of decimal places sign : arithmetic sign sin : trigonometric sine sinh\",\n \"will filter the data when 'ts' is greater than November 1993 the 3rd.\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] #\",\n \"label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}'\",\n \"50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {},\",\n \"[list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"an aggregation. Parameters ---------- by: str, optional vColumn to use to partition the\",\n \"total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem\",\n \"elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT *\",\n \"{}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, )\",\n \"setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the\",\n \"\\\"\\\", max_cardinality: int = 6, nbins: int = 0, h: float = 0,\",\n \"the discretization. topk : Keeps the topk most frequent categories and merge the\",\n \"return tablesample(values) # ---# def discretize( self, method: str = \\\"auto\\\", h: float\",\n \"must be a list of at least one element to use to order\",\n \"( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor )\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See Also --------\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the\",\n \"slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the\",\n \"warning_message = \\\"Can not normalize {} using the MIN and the MAX. MAX\",\n \"query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile\",\n \"Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns\",\n \"the specific language governing permissions and # limitations under the License. # #\",\n \"the vDataFrame \\\"heavier\\\" if it is used to compute other vColumns. Parameters ----------\",\n \"executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for\",\n \"of the different records. For example, to check if Badr and Fouad are\",\n \"self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations to compute the optimal\",\n \"not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the\",\n \"plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes\",\n \"result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---#\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize :\",\n \"AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP\",\n \"lower: float, optional Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame\",\n \"{}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality\",\n \"[int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} -\",\n \"if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if\",\n \"\\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\",\",\n \"\\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"):\",\n \"[ item[0] for item in executeSQL( query=query, title=\\\"Computing the average of the {}'s\",\n \"str = \\\"\\\", by: list = [], order_by: list = [], ): \\\"\\\"\\\"\",\n \"= \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0,\",\n \"] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\",\",\n \"Returns the vColumn memory usage. Returns ------- float vColumn memory usage (byte) See\",\n \"1 that represents the quantile. For example: 0.25 represents Q1. approx: bool, optional\",\n \"\\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\\",\n \"regular expression in each record of the vColumn. vDataFrame[].extract : Extracts the regular\",\n \"vColumn using 'mad' (median absolute deviation). Returns ------- float mad See Also --------\",\n \"greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also --------\",\n \"---------- by: str, optional vColumn to use to partition the data. h: float,\",\n \"distributed under the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT\",\n \"element. Parameters ---------- dropna: bool, optional If set to True, NULL values will\",\n \"date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the\",\n \"sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] )\",\n \"\\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied to the vColumn {}\\\\n{}\",\n \"the data when 'ts' is greater than November 1993 the 3rd. plot_median: bool,\",\n \"\\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"\\\"(CASE \\\" for i in range(1, n): trans += \\\"WHEN {} BETWEEN {}\",\n \"/ ( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem]\",\n \"object. Parameters ---------- *args / **kwargs Any optional parameter to pass to the\",\n \"frequent categories and merge the other into one unique category. h: float, optional\",\n \"Returns ------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"int/tuple, optional Maximum number of distinct elements for vColumns 1 and 2 to\",\n \"alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the\",\n \"is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if\",\n \"data (Z-Score), if the absolute value of the record is greater than the\",\n \"cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"less frequent elements will be gathered together to create a new category :\",\n \"to True, NULL values will not be considered during the computation. Returns -------\",\n \"the following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn. One\",\n \"max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] ) method = method.lower() assert (method\",\n \"For example, if n = 1 then this method will return the mode\",\n \"date, optional Input Start Date. For example, time = '03-11-1993' will filter the\",\n \"= executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return pre_comp assert n\",\n \"vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]),\",\n \"method ) ) else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return\",\n \"`\\\\ / / # | \\\\/ / / / # |______ / /\",\n \"Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent See Also --------\",\n \"---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__()\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias),\",\n \": Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])])\",\n \"the vColumn (only if the vColumn type is date like). The vColumn will\",\n \"vColumn memory usage. Returns ------- float vColumn memory usage (byte) See Also --------\",\n \">= 2, ParameterError( \\\"Parameter 'k' must be greater or equals to 2 in\",\n \"(Z-Score), if the absolute value of the record is greater than the threshold\",\n \"the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns = [\",\n \"by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif ( ((distinct_count <\",\n \"self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int =\",\n \"= int(float(count / int(nbins))) assert nb != 0, Exception( \\\"Not enough values to\",\n \"{} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional\",\n \"boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"it will represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not\",\n \"to use to fill the vColumn outliers. mean : Replaces the upper and\",\n \"use to compute the optimal h. auto : Combination of Freedman Diaconis and\",\n \"from verticapy.errors import * ## # # __ __ ______ ______ __ __\",\n \"self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing\",\n \"of at least one element to use to order the data\\\" ) desc\",\n \"\\\\u26A0 Warning : SQL code generation will be slower if the vDataFrame has\",\n \"index mad : median absolute deviation max : maximum mean : average median\",\n \") donut = True if pie_type == \\\"donut\\\" else False rose = True\",\n \"time of the learning and scoring phases. xlim: tuple, optional Set the x\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return\",\n \"\\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the\",\n \"elements in the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional\",\n \"of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\")\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\"))\",\n \"|. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # / __\",\n \"(count distinct) var : variance Other aggregations could work if it is part\",\n \"self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func: str, x: float =\",\n \"custom_lines = [] columns = self.parent[by].distinct() for idx, column in enumerate(columns): param =\",\n \"[int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha =\",\n \"\\\"\\\" if index < 0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM\",\n \"LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = (\",\n \"import verticapy from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import\",\n \"variable must be composed of two flower brackets {}. For example to apply\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of, max_cardinality,\",\n \"split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {})\",\n \"alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if\",\n \"elem in result if elem[1] != None ] ), ) stddev = \\\"DECODE({},\",\n \"tangent x: int/float, optional If the function has two arguments (example, power or\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return\",\n \"= KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(),\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int =\",\n \"See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k,\",\n \"Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"method: str, optional Method to use to fill the vColumn outliers. mean :\",\n \"), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax,\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return\",\n \"--------------------------------------------------------------------------- Applies the absolute value function to the input vColumn. Returns ------- vDataFrame\",\n \"optional Number of elements to skip. Returns ------- tablesample An object containing the\",\n \"[1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") +\",\n \"0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) #\",\n \"(self.category() == \\\"int\\\") else \\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"):\",\n \"NULL values will not be considered during the computation. Returns ------- tablesample An\",\n \"vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn is numerical.\",\n \"copy with the specified name. \\\\u26A0 Warning : SQL code generation will be\",\n \"specific records are in the vColumn and it returns the new vDataFrame of\",\n \"[str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError(\",\n \"/ 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in\",\n \"# _ # \\\\ / _ __|_. _ _ |_) # \\\\/ (/_|\",\n \"parameter 'new_name', you'll be able to solve this issue.\\\" ) self.add_copy(new_name) parent =\",\n \"and Fouad are in the vColumn. You can write the following list: [\\\"Fouad\\\",\",\n \"__ __ __ __ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __\",\n \"\\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---#\",\n \"to compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns 1\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality,\",\n \"utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame\",\n \"If set to True, the lowest element of the list will be included.\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ---------- method:\",\n \"of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]),\",\n \"in the vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns -------\",\n \"ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date,\",\n \"= executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias,\",\n \"def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit: b). Returns\",\n \"[str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list,\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv =\",\n \"will be considered as categorical. numcol: str, optional Numerical vColumn to use when\",\n \"drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"atan : trigonometric inverse tangent cbrt : cube root ceil : value up\",\n \"to the upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper:\",\n \"An object containing the result. For more information, see utilities.tablesample. See Also --------\",\n \"False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element.\",\n \"\\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp\",\n \"float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"[\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by] for elem\",\n \") upper_when = ( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper)\",\n \"the Equal Frequency discretization\\\" ) total, query, nth_elems = nb, [], [] while\",\n \"cotangent exp : exponential function floor : value down to the next whole\",\n \"instead of the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"= 1 if drop_first else 0 for k in range(len(distinct_elements) - n): name\",\n \"({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha,\",\n \"str = \\\"\\\", h: float = 0, max_cardinality: int = 8, cat_priority: list\",\n \"\\\\ / # \\\\/ # _ # \\\\ / _ __|_. _ _\",\n \"self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the\",\n \"---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False\",\n \"---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The\",\n \"... END odd : CASE ... WHEN vColumn = argv[2 * i] THEN\",\n \"auto : Mean for the numerical and Mode for the categorical vColumns. bfill\",\n \"Extracts the regular expression in each record of the vColumn. The vColumn will\",\n \"the method 'same_freq'\\\" ) count = self.count() nb = int(float(count / int(nbins))) assert\",\n \"of elements. density : Percentage of the distribution. mean : Average of the\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query)\",\n \"this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was\",\n \"self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median,\",\n \"str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression\",\n \"{}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def\",\n \"\\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] != None else\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to\",\n \"self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total)\",\n \"result[i - 1], result[i], result[i - 1], result[i] ) trans += \\\" ELSE\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail\",\n \"KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot(\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std\",\n \"self elif n == 1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({})\",\n \"# # Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc\",\n \"works on numerical / date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length\",\n \"\\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP BY\",\n \"\\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0]\",\n \"True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn.\",\n \"the absolute value of the record is greater than the threshold, it will\",\n \"sinh : hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent\",\n \"self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias, method\",\n \"# ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming\",\n \"using the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as st return\",\n \"Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean : Average.\",\n \"The vColumn will be transformed. Parameters ---------- field: str The field to extract.\",\n \"sequentialize # data transformation operations, and offers beautiful graphical options. # # VerticaPy\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns -------\",\n \"median min : minimum mode : most occurent element percent : percent of\",\n \"mean encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message =\",\n \"check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix,\",\n \"in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is in\",\n \"in self.transformations] total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor =\",\n \"return parent # ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn\",\n \"above. The idea is simple: instead of moving # data around for processing,\",\n \"-------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x,\",\n \"Iterable from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import\",\n \"count : number of non-missing elements cvar : conditional value at risk dtype\",\n \"the input method. Parameters ---------- method: str, optional Method to use to fill\",\n \"--------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter\",\n \"if not (result) else result[0][0] if not (dropna): n = \\\"\\\" if (n\",\n \"!= \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin =\",\n \"Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces\",\n \"index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if index_start\",\n \"the vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes\",\n \"BY 1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT {}, ord, non_events,\",\n \"Z-Score (avg and std). (x - avg) / std robust_zscore : Normalization using\",\n \"is in ffill|pad|bfill|backfill then 'order_by' must be a list of at least one\",\n \"BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result =\",\n \"elements to display. Returns ------- tablesample An object containing the result. For more\",\n \"[best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---#\",\n \"0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset\",\n \"query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) /\",\n \": Normalization using the Z-Score (avg and std). (x - avg) / std\",\n \"-------- vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT\",\n \"return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the\",\n \"= \\\"\\\", h: float = 0, max_cardinality: int = 8, cat_priority: list =\",\n \"object See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based\",\n \"conditions, column = [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem\",\n \"self.parent See Also -------- vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\"\",\n \"identify outliers. After normalizing the data (Z-Score), if the absolute value of the\",\n \"the result of using previously the method on the vColumn \\\" \\\"or simply\",\n \"maximum mean : average median : median min : minimum mode : most\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See\",\n \"(date, datetime, timestamp...) or numerical. by: str, optional vColumn to use to partition\",\n \"the Gaussian distribution to define the outliers. After normalizing the data (Z-Score), if\",\n \"prefix_sep: str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ):\",\n \"( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str,\",\n \"check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\",\",\n \"---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ----------\",\n \"be the result of using previously the method on the vColumn \\\" \\\"or\",\n \"store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular\",\n \"True if len(args) > 0: column = args[0] elif \\\"column\\\" in kwargs: column\",\n \"= [elem for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem]\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division by 0 is\",\n \"children vColumns whereas one vColumn can only have one parent. catalog: dict, optional\",\n \"{}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\":\",\n \"nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias:\",\n \"elif ( ((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\")) or not\",\n \"self.isdate(), TypeError( \\\"cut only works on numerical / date-like vColumns.\\\" ) assert len(breaks)\",\n \"\\\"x\\\"), ) ) return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when\",\n \"kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel.\",\n \"must be numerical for Normalization\\\") return self.parent # ---# def nsmallest(self, n: int\",\n \"Parameters ---------- add_history: bool, optional If set to True, the information will be\",\n \"vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"the upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float,\",\n \"= self.parent[by].distinct() for idx, column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]}\",\n \"== \\\"float\\\" else \\\"\\\" if index < 0: index += self.parent.shape()[0] query =\",\n \"can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of\",\n \"self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the top{} categories\",\n \"mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN\",\n \"True, NULL values will not be considered during the computation. n: int, optional\",\n \"to the length of parameter 'labels' + 1 or parameter 'labels' must be\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias),\",\n \"numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width.\",\n \"NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL(\",\n \"self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The\",\n \"expr: str = \\\"\\\", by: list = [], order_by: list = [], ):\",\n \"= new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias\",\n \"the mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent element.\",\n \"width. Parameters ---------- method: str, optional Method to use to compute the optimal\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\"\",\n \"\\\"Length of parameter 'breaks' must be greater or equal to 2.\\\" ) assert\",\n \"self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True,\",\n \"occurent element. Parameters ---------- dropna: bool, optional If set to True, NULL values\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy\",\n \"approximate density function. Increasing this parameter will increase the precision but will also\",\n \"function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate #\",\n \"the box plot of the vColumn. Parameters ---------- by: str, optional vColumn to\",\n \"= ( parent, alias, [elem for elem in transformations], ) self.catalog = {\",\n \"\\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str,\",\n \") cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct()\",\n \"plot of the input vColumn based on an aggregation. Parameters ---------- by: str,\",\n \"expression in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\"\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def\",\n \"= True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters\",\n \"(sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method\",\n \"conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ]\",\n \"a specified number of decimal places sign : arithmetic sign sin : trigonometric\",\n \"+ prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else 0 for k\",\n \"(method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format(\",\n \"vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func =\",\n \"== 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna)\",\n \"[\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search. See Also --------\",\n \"\\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\" )\",\n \"NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method\",\n \"= self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return\",\n \"--------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x: float If\",\n \"str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) /\",\n \"ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram of\",\n \"the comma. Parameters ---------- n: int Number of digits to keep after the\",\n \"as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened\",\n \") fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 /\",\n \"-({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self):\",\n \"based on an aggregation. Parameters ---------- by: str, optional vColumn to use to\",\n \"k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response:\",\n \"method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {}\",\n \"list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---# def\",\n \": q quantile (ex: 50% for the median) prod : product range :\",\n \"used for the discretization (must be > 1) Returns ------- tablesample An object\",\n \"+= final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,\",\n \"transformations. \\\"\\\"\\\" # # Special Methods # # ---# def __init__( self, alias:\",\n \"def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are\",\n \"ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check = True if len(args)\",\n \"MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE /\",\n \"apply it. This parameter is very useful for testing to be able to\",\n \"= 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias,\",\n \"VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({})\",\n \"= self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines = []\",\n \"float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot\",\n \"on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate # ---#\",\n \": percent of non-missing elements q% : q quantile (ex: 50% for the\",\n \"start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area:\",\n \"= (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem]\",\n \"[ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {}\",\n \"CENTURY / DAY / DECADE / DOQ / DOW / DOY / EPOCH\",\n \"2 in case of discretization using the method 'smart'.\\\" ) assert response, ParameterError(\",\n \"vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self, func: list):\",\n \"if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\",\",\n \"the mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result) else result[0][0] if\",\n \"numerical or of type date like. Optimized h will be computed if the\",\n \") title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) #\",\n \"\\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1, close_l =\",\n \"aggregation. vColumns will memorize the already computed aggregations to gain in performance. The\",\n \"len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(),\",\n \"you'll be able to solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent,\",\n \"elem[1] != None else \\\"NULL\\\", ) for elem in result if elem[1] !=\",\n \"+= [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"\\\"gaussian\\\", nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"will be drawn. ax: Matplotlib axes object, optional The axes to plot on.\",\n \"--------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn. The vColumn\",\n \"quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if\",\n \"name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters\",\n \"--------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation. Parameters ----------\",\n \"to True, the method will return the transformation used instead of the parent\",\n \"self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({})\\\".format(\",\n \"value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\"\",\n \"(\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]),\",\n \"the merging category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of\",\n \"sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try:\",\n \"filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations\",\n \"warning_message = \\\"Can not normalize {} using a Z-Score - The Standard Deviation\",\n \"bins will be computed. h: float, optional Interval width of the bar. If\",\n \"return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"the discretization (must be > 1) Returns ------- tablesample An object containing the\",\n \"a function to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\"\",\n \"cmax - cmin == 0: warning_message = \\\"Can not normalize {} using the\",\n \"Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame self.parent See\",\n \"[int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \"clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser\",\n \"events FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y, query, ) query\",\n \"] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else:\",\n \"* COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4})\",\n \"prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] )\",\n \"vColumn must be numerical for Normalization\\\") return self.parent # ---# def nsmallest(self, n:\",\n \"/\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____\",\n \"{} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax,\",\n \"] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1, 0])\",\n \"'lower' or 'upper' must have a numerical value\\\" ) lower_when = ( \\\"WHEN\",\n \"gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = []\",\n \"for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) #\",\n \"\\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN {} > {}\",\n \"): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for i in range(len(values[elem])):\",\n \"be converted to {}\\\".format( e, self.alias, dtype ) ) # ---# def avg(self):\",\n \"an optimised interval will be computed. nbins: int, optional Number of bins used\",\n \") expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations =\",\n \"\\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\":\",\n \"considered during the computation. n: int, optional Integer corresponding to the offset. For\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness #\",\n \"transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also\",\n \"FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({},\",\n \"vColumn. The vColumn will be transformed. Parameters ---------- start: int Start of the\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {}\",\n \"vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\",\",\n \"else False rose = True if pie_type == \\\"rose\\\" else False if of:\",\n \"value\\\" ) lower_when = ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower,\",\n \"4.0, use_threshold: bool = True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills\",\n \"(\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut =\",\n \"part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method:\",\n \"different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {},\",\n \"'{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start:\",\n \"advanced analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg =\",\n \"\\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query =\",\n \"= \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias,\",\n \"value of the record is greater than the threshold it will be considered\",\n \"CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events\",\n \"obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless\",\n \"float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0]\",\n \"parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame\",\n \"number raised to the power of another number round : rounds a value\",\n \"threshold, it will be considered as an outlier. use_threshold: bool, optional Uses the\",\n \"== \\\"zscore\\\": if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\",\",\n \"None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE\",\n \"elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype =\",\n \"int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index <\",\n \") result = [distinct_count, self.count()] + [item[1] for item in query_result] index =\",\n \"in result], } return tablesample(values) # ---# def value_counts(self, k: int = 30):\",\n \"by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"\\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format(\",\n \"# ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to\",\n \"the numerical and Mode for the categorical vColumns. bfill : Back Propagation of\",\n \"1 and 2 bars. It is only valid if the vColumns are numerical.\",\n \"the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes\",\n \"executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {}\",\n \"check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else\",\n \"expression to replace. value: str, optional New value. Returns ------- vDataFrame self.parent See\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql):\",\n \"\\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n > 0: warning_message =\",\n \"iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing\",\n \"verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] =\",\n \"# ____________ ______ # / __ `\\\\ / / # | \\\\/ /\",\n \"of the vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn\",\n \"step: bool, optional If set to True, draw a Step Plot. ax: Matplotlib\",\n \"FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality\",\n \"query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\"\",\n \"element (Constant Interpolation). mean : Average. median : median. mode : mode (most\",\n \"computed. pie_type: str, optional The type of pie chart. auto : Regular pie\",\n \"y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {})\",\n \"mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep,\",\n \"than November 1993 the 3rd. end_date: str / date, optional Input End Date.\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series\",\n \"!= \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()]\",\n \"colors = gen_colors() if not xlim: xmin = self.min() xmax = self.max() else:\",\n \"# ---# def boxplot( self, by: str = \\\"\\\", h: float = 0,\",\n \"int])]) assert (lower != None) or (upper != None), ParameterError( \\\"At least 'lower'\",\n \"h: float = 0, nbins: int = -1, k: int = 6, new_category:\",\n \"OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column =\",\n \"self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage.\",\n \"set to True, the method will return the transformation used instead of the\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self,\",\n \"[int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold:\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self,\",\n \"two arguments (example, power or mod), 'x' represents the second argument. Returns -------\",\n \"including the 2 quantiles used to draw the Plot. start_date: str / date,\",\n \"topk : Keeps the topk most frequent categories and merge the other into\",\n \"---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing.\",\n \"tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format(\",\n \"h will be picked or computed) nbins: int, optional Number of nbins. If\",\n \"records. The vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns\",\n \"\\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if\",\n \"labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or\",\n \"vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\"\",\n \"idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ),\",\n \"[self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn. Parameters ---------- n:\",\n \"= 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations)\",\n \"--------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as percents. Parameters\",\n \"bool, optional If set to True, the approximate median is returned. By setting\",\n \"0.0001: h = round(h, 4) elif h > 0.000001: h = round(h, 6)\",\n \": Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations,\",\n \"\\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values =\",\n \"to gain in performance. The catalog will be updated when the parent vDataFrame\",\n \"( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn\",\n \"data. method: str, optional The method to use to aggregate the data. count\",\n \"Normalization using the Robust Z-Score (median and mad). (x - median) / (1.4826\",\n \"defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality: int, optional\",\n \"/ # \\\\_______/ / / # ______ / / # \\\\ / /\",\n \"Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int,\",\n \"new_name) ) return parent # ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds\",\n \"(\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn\",\n \"user transformations. If the vDataFrame represents the entire relation, a vColumn can be\",\n \"else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]}\",\n \"i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also\",\n \"add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame.\",\n \"Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns\",\n \"be 'minute' 'hour'... start: bool, optional If set to True, the record will\",\n \"self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column\",\n \"'skewness'. Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self, ts: str,\",\n \": Adds a new vColumn labeled with 0 and 1 (1 meaning global\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg #\",\n \"vColumn is null, 1 otherwise. expr: str, optional SQL expression. by: list, optional\",\n \"self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\")\",\n \"date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower()\",\n \"You may not use this file except in compliance with the License. #\",\n \"if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema,\",\n \"verticapy.toolbox import * from verticapy.errors import * ## # # __ __ ______\",\n \"p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if\",\n \"1 or parameter 'labels' must be empty.\\\" ) conditions, column = [], self.alias\",\n \"trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root tan :\",\n \"of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the\",\n \"= (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method ==\",\n \"already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to solve\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM\",\n \") else: final_transformation = [ ( \\\"({} - {}) / {}({} - {})\\\".format(\",\n \"for each vColumn category. In this case, the parameter 'numcol' must be defined.\",\n \"float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float):\",\n \"MINUTE / MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR /\",\n \"[str(count)]) ) query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY\",\n \"sauv[elem] elif elem == None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem]\",\n \"if pie_type == \\\"donut\\\" else False rose = True if pie_type == \\\"rose\\\"\",\n \"setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A\",\n \"it's better practice to use this method when first preparing your data. Parameters\",\n \"- median) / (1.4826 * mad) minmax : Normalization using the MinMax (min\",\n \"\\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM (SELECT\",\n \"new category : 'Others'. cat_priority: list, optional List of the different categories to\",\n \"the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self):\",\n \"[str])]) try: query = \\\"SELECT {}::{} AS {} FROM {} WHERE {} IS\",\n \"a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias]\",\n \"text_info ) ) return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"the input element from the vColumn. Parameters ---------- x: float If the vColumn\",\n \"# ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the\",\n \"optional Method to use to normalize. zscore : Normalization using the Z-Score (avg\",\n \"= 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit:\",\n \"offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def isbool(self):\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head :\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an aggregation.\",\n \"label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories\",\n \"self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"[] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result\",\n \"**updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"],\",\n \"in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM\",\n \"transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x:\",\n \"WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the\",\n \"self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"> 1) k: int, optional The integer k of the 'topk' method. new_category:\",\n \": kth most occurent element (ex: top1 for the mode) topk_percent : kth\",\n \"the vColumn using 'mad' (median absolute deviation). Returns ------- float mad See Also\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\"\",\n \"of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool,\",\n \"{} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\"\",\n \"= [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"None), ValueError( \\\"vColumn doesn't allow slicing having steps different than 1.\\\" ) index_stop\",\n \"NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype)\",\n \"item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result]\",\n \"Function in pure SQL used to transform the vColumn. The function variable must\",\n \") for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [\",\n \"to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self,\",\n \"if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in\",\n \"to use for the discretization. topk : Keeps the topk most frequent categories\",\n \"vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by] check_types( [ (\\\"method\\\",\",\n \"/ / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\\",\n \"vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\",\",\n \"VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 ) result\",\n \"--------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ---------- threshold: float, optional Uses the\",\n \"( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075,\",\n \"executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k if k > 0\",\n \"self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min,\",\n \"decimal, warnings, datetime from collections.abc import Iterable from typing import Union # VerticaPy\",\n \"the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\"\",\n \"= { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\":\",\n \"number of bins will be computed. h: float, optional Interval width of the\",\n \"= False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating\",\n \"title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem\",\n \"self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns\",\n \"vDataFrame.outliers : Adds a new vColumn labeled with 0 and 1 (1 meaning\",\n \"\\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\\",\n \"[\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method =\",\n \"an input 'quantile'. Parameters ---------- x: float A float between 0 and 1\",\n \"the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent =\",\n \"---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold:\",\n \"ts: str TS (Time Series) vColumn to use to order the data. The\",\n \"# (c) Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed\",\n \"nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot\",\n \"be computed. nbins: int, optional Number of bins used for the discretization (must\",\n \"to the parent vDataFrame. Parameters ---------- name: str Name of the copy. Returns\",\n \"kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple = None, ax=None,\",\n \"/\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/\",\n \"str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date:\",\n \"Dropping a vColumn means simply not selecting it in the final generated SQL\",\n \"vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype:\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The\",\n \"greater or equals to 2 in case of discretization using the method 'smart'.\\\"\",\n \"\\\"{}\\\" ) ) elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT\",\n \"on a response column to find the most relevant interval to use for\",\n \"), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]),\",\n \"name ) ) return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER\",\n \"cat_priority: list, optional List of the different categories to consider when drawing the\",\n \"in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val =\",\n \"[item for sublist in query_result for item in sublist] # ---# def div(self,\",\n \"if the vColumn is numerical, False otherwise. Returns ------- bool True if the\",\n \"else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx ==\",\n \"(\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\",\",\n \"---------- val: int/float/str, optional Value to use to impute the vColumn. method: dict,\",\n \"... ELSE argv[n] END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when :\",\n \"= \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query\",\n \"Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func,\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute\",\n \"str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type.\",\n \"self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ),\",\n \"Random Forest on a response column to find the most relevant interval to\",\n \"to False else the lower and upper ZScores. threshold: float, optional Uses the\",\n \"= ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] =\",\n \"), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import\",\n \"val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr:\",\n \"Encodes the vColumn using a bijection from the different categories to [0, n\",\n \"splits when 'method' is set to 'smart'. A RF Regressor will be trained\",\n \"the threshold it will be considered as an outlier. use_threshold: bool, optional Uses\",\n \"self.alias, y, y, query, ) query = \\\"SELECT {}, ord, non_events, events, non_events\",\n \"/ int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 -\",\n \"to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns -------\",\n \"3rd. plot_median: bool, optional If set to True, the Median will be drawn.\",\n \"return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit: str\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail :\",\n \"in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or\",\n \"self.parent.format_colnames(y) assert self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary to use\",\n \"[\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\": pre_comp\",\n \"return [item for sublist in query_result for item in sublist] # ---# def\",\n \"= \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] =\",\n \"the intervals will be closed on the right. Returns ------- vDataFrame self.parent See\",\n \"vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\"\",\n \"result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"]\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based\",\n \"on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if n ==\",\n \"self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat:\",\n \"Replaces the regular expression matches in each of the vColumn record by an\",\n \"( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if (by)\",\n \"vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected\",\n \"{}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {},\",\n \"self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be numerical\\\"\",\n \"Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See Also --------\",\n \"be able to solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item\",\n \"dtype ) ) return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn\",\n \"quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already\",\n \"index.start if not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start\",\n \"Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes\",\n \"encoding. Parameters ---------- argv: object Any amount of expressions. The expression generated will\",\n \"elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str = \\\"auto\\\"):\",\n \"str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the\",\n \"include_lowest: bool = True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the\",\n \"optional vColumn to use to partition the data. method: str, optional The method\",\n \"int Size of the slicing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains\",\n \"= verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name\",\n \"{}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {},\",\n \"len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\",\",\n \"[distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\",\",\n \"LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\",\",\n \"float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {})\",\n \"AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step: bool = False,\",\n \"if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self,\",\n \"{} was added to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent #\",\n \"in range(1, n): trans += \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]'\",\n \"the regular expression matches in each of the vColumn records by an input\",\n \"if stddev == 0: warning_message = \\\"Can not normalize {} using a Z-Score\",\n \"of the Random Forest model parameters used to compute the best splits when\",\n \"to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches\",\n \"|~) _ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # /\",\n \"another number round : rounds a value to a specified number of decimal\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins,\",\n \"by: str, optional vColumn to use to partition the data. bandwidth: float, optional\",\n \"= float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def\",\n \"= \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit,\",\n \"of discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = (\",\n \"'\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\",\",\n \"\\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\" for i in range(1,\",\n \"= self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method ==\",\n \": Computes the number of matches for the regular expression in each record\",\n \"raise # ---# def describe( self, method: str = \\\"auto\\\", max_cardinality: int =\",\n \"\\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not\",\n \"for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total\",\n \"the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\",\",\n \") assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\",\",\n \"The vColumn {} was transformed using a mean encoding with {} as Response\",\n \"(\\\"x\\\", x, [int, float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\",\",\n \") except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx: bool\",\n \"list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search. See Also\",\n \"def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def\",\n \"+ \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\"\",\n \"= None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format(\",\n \"for elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self):\",\n \"def slice(self, length: int, unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\"\",\n \"|_) # \\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy is a\",\n \"{} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else:\",\n \") else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in\",\n \"cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({})\",\n \"'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in\",\n \"vColumn using 'count' (Number of non-Missing elements). Returns ------- int number of non-Missing\",\n \"the vColumn. Parameters ---------- func: str, Function in pure SQL used to transform\",\n \"\\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans]\",\n \"(\\\"n\\\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if\",\n \"numerical value\\\" ) lower_when = ( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\",\",\n \"AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS\",\n \"print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj,\",\n \"or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1\",\n \") total, query, nth_elems = nb, [], [] while total < int(float(count /\",\n \"COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query +=\",\n \"\\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique()\",\n \"(\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by\",\n \"\\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None\",\n \"of decimal places sign : arithmetic sign sin : trigonometric sine sinh :\",\n \"The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif\",\n \"Returns ------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate :\",\n \"store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result\",\n \"pie chart. auto : Regular pie chart. donut : Donut chart. rose :\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns ------- float product See Also --------\",\n \"is empty\\\\nIf you want to normalize by grouping by elements, please use a\",\n \"self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations\",\n \"ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format( e, self.alias, dtype\",\n \"Also -------- vDataFrame[].tail : Returns the a part of the vColumn. \\\"\\\"\\\" return\",\n \"vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias))\",\n \"axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn\",\n \"trained if the response is numerical (except ints and bools), a RF Classifier\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of the\",\n \"= \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun =\",\n \"instead of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part :\",\n \"2) elif h > 0.0001: h = round(h, 4) elif h > 0.000001:\",\n \"of a numerical column for each vColumn category. In this case, the parameter\",\n \"drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] +\",\n \"case of discretization using the method 'same_freq'\\\" ) count = self.count() nb =\",\n \"check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ]\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the\",\n \"an offset and a limit). Parameters ---------- limit: int, optional Number of elements\",\n \"/\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\ \\\\ # \\\\\",\n \"self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]:\",\n \") ) return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"of: str, optional The vColumn to use to compute the aggregation. h: int/float/tuple,\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ]\",\n \"computed. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"None) or (upper != None), ParameterError( \\\"At least 'lower' or 'upper' must have\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors =\",\n \"self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\",\",\n \"License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS\",\n \"= 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with\",\n \"'n' must be greater or equal to 1\\\") where = \\\" WHERE {}\",\n \"vColumn based on an aggregation. Parameters ---------- method: str, optional The method to\",\n \"trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent\",\n \"= \\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple]\",\n \"self.category())] self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem] =\",\n \"(\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError(\",\n \"Draws the bar chart of the vColumn based on an aggregation. Parameters ----------\",\n \"warning_message = ( \\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning)\",\n \"See Also -------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns.\",\n \"width of the bar. If empty, an optimized h will be computed. ax:\",\n \"PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS\",\n \"= (6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ):\",\n \"] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return\",\n \"vColumn can only have one parent. catalog: dict, optional Catalog where each key\",\n \"self.max() else: xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n\",\n \"= \\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE\",\n \"\\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not normalize {} using a\",\n \"if cmax - cmin == 0: warning_message = \\\"Can not normalize {} using\",\n \"Also -------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds\",\n \"\\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][\",\n \"/ # \\\\ / / / # \\\\ / / / # \\\\_______/\",\n \"Parameters ---------- length: int Slice size. unit: str, optional Slice size unit. For\",\n \"split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 ) result = executeSQL( query=query,\",\n \"optional vColumns used in the partition. return_trans: bool, optimal If set to True,\",\n \"the data. bandwidth: float, optional The bandwidth of the kernel. kernel: str, optional\",\n \"categories and merge the other into one unique category. h: float, optional The\",\n \"to create a new category : 'Others'. cat_priority: list, optional List of the\",\n \"< {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\"\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"(must be > 1) k: int, optional The integer k of the 'topk'\",\n \"/ (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h =\",\n \"{} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL(\",\n \"non-missing elements q% : q quantile (ex: 50% for the median) prod :\",\n \"mode of the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See\",\n \"# # Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\\\"Computing the average of\",\n \"h will be picked or computed) nbins: int, optional Number of bins. If\",\n \"= \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h:\",\n \"# ---# def median( self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\"\",\n \"Uses only categorical aggregations during the computation. cat_stats : Computes statistics of a\",\n \"+= ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\"\",\n \"def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # # ---#\",\n \"self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical / date-like vColumns.\\\" )\",\n \"the regular expression in each record of the vColumn. vDataFrame[].extract : Extracts the\",\n \"If empty, an optimized h will be computed. pie_type: str, optional The type\",\n \"# ---# def normalize( self, method: str = \\\"zscore\\\", by: list = [],\",\n \"start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be\",\n \"self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem in\",\n \"standard deviation topk : kth most occurent element (ex: top1 for the mode)\",\n \"Parameters ---------- func: str Function to use to transform the vColumn. abs :\",\n \"else 0 for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k)\",\n \"print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in copy_trans] for elem in\",\n \"from the different categories to [0, n - 1] (n being the vColumn\",\n \"cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes\",\n \"(\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by\",\n \"beautiful graphical options. # # VerticaPy aims to do all of the above.\",\n \"By setting this parameter to False, the function's performance can drastically decrease. Returns\",\n \"n = 1 then this method will return the mode of the vColumn.\",\n \"records by an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat,\",\n \"\\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by == []: if fun\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an\",\n \"median) / (1.4826 * mad) minmax : Normalization using the MinMax (min and\",\n \"the parameter 'x' will represent the number of seconds, otherwise it will represent\",\n \") warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if\",\n \"start: bool, optional If set to True, the record will be sliced using\",\n \"they occur, and other statistical information. Parameters ---------- k: int, optional Number of\",\n \"self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat: str): \\\"\\\"\\\"\",\n \"if self.category() == \\\"float\\\" else \\\"\\\" if index < 0: index += self.parent.shape()[0]\",\n \"h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges = max(\",\n \"to use to determine if the vColumn will be considered as categorical. numcol:\",\n \"be numerical to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len(\",\n \"already the alias {name}.\\\\nBy changing the parameter 'name', you'll be able to solve\",\n \"left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import\",\n \"Unless required by applicable law or agreed to in writing, software # distributed\",\n \"(), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {}\",\n \"abstractions. Parameters ---------- alias: str vColumn alias. transformations: list, optional List of the\",\n \"self, threshold: float = 4.0, use_threshold: bool = True, alpha: float = 0.05\",\n \"vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds\",\n \"vColumn 'of' (ex: 50% to get the median). It can also be a\",\n \"[bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0, 1], [1,\",\n \"= (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date]\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False,\",\n \"data when 'ts' is greater than November 1993 the 3rd. area: bool, optional\",\n \"IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n\",\n \"set to True, the Median will be drawn. ax: Matplotlib axes object, optional\",\n \"= {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total =\",\n \"Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \": Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using\",\n \"of {} partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif\",\n \"] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method\",\n \"/ binary / spatial / uuid / undefined Returns ------- str vColumn category.\",\n \"else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if\",\n \"--------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ---------- dropna: bool, optional If\",\n \"x: float If the vColumn type is date like (date, datetime ...), the\",\n \"= self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins, h,\",\n \"elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \": Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types(\",\n \"normalize {} using the MIN and the MAX. MAX = MIN !\\\".format( self.alias\",\n \"the vColumn {} named {} was added to the vDataFrame.\\\".format( self.alias, name )\",\n \"# \\\\/ # _ # \\\\ / _ __|_. _ _ |_) #\",\n \"response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only\",\n \"check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {} WHERE {} IS\",\n \"vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT\",\n \"# _____________ / / # \\\\ / / / # \\\\ / /\",\n \"] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn\",\n \"desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by =\",\n \") if return_trans: return \\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin,\",\n \"The vColumn type must be date like (date, datetime, timestamp...) or numerical. by:\",\n \"dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers\",\n \"woe, CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of =\",\n \"p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({}\",\n \"bins. smart : Uses the Random Forest on a response column to find\",\n \"vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin : Looks if\",\n \"(dropna) and (pre_comp != None): return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n'\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]),\",\n \"[\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self):\",\n \"val = self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({},\",\n \"n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not\",\n \"), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias)\",\n \"be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the\",\n \"ffill|pad|bfill|backfill then 'order_by' must be a list of at least one element to\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding.\",\n \"Adds a new vColumn labeled with 0 and 1 (1 meaning global outlier).\",\n \"-------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a new\",\n \"# # VerticaPy aims to do all of the above. The idea is\",\n \"mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns -------\",\n \"def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn\",\n \"considered during the computation. Returns ------- tablesample An object containing the result. For\",\n \"( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ]\",\n \": Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by = [by]\",\n \"if nbins <= 0: h = self.numh() else: h = (self.max() - self.min())\",\n \"nbins: int, optional Number of bins. If empty, an optimized number of bins\",\n \"result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"]\",\n \"= self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\",\",\n \">= 1, ParameterError(\\\"Parameter 'n' must be greater or equal to 1\\\") where =\",\n \"(No h will be picked or computed) nbins: int, optional Number of bins.\",\n \"columns=[self.alias]).transpose() agg = aggregate # ---# def apply(self, func: str, copy_name: str =\",\n \"max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for\",\n \"during the computation. max_cardinality: int, optional Cardinality threshold to use to determine if\",\n \"* 1.01 / nbins if h > 0.01: h = round(h, 2) elif\",\n \"kernel: str, optional The method used for the plot. gaussian : Gaussian kernel.\",\n \"category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func\",\n \"elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category()\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of\",\n \"[\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else: result = ( self.parent.describe(\",\n \"_ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # /\",\n \"NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM\",\n \": Freedman Diaconis [2 * IQR / n ** (1 / 3)] sturges\",\n \": Draws the Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n:\",\n \"the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"\\\"min\\\", \\\"max\\\"]) index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and\",\n \"lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to\",\n \"3rd. end_date: str / date, optional Input End Date. For example, time =\",\n \"the 3rd. plot_median: bool, optional If set to True, the Median will be\",\n \"aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int,\",\n \"intervals will be closed on the right. Returns ------- vDataFrame self.parent See Also\",\n \"(ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {})\",\n \"see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias]\",\n \"'{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\",\",\n \"self.alias, text_info ) ) return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize\",\n \"nbins: int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query =\",\n \"VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import * from\",\n \"return_trans: return \\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if\",\n \"self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element\",\n \"h: float, optional Interval width if the vColumn is numerical or of type\",\n \"\\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"len(args) > 0: column = args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"]\",\n \"category)] try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,\",\n \"for i in range(1, n): trans += \\\"WHEN {} BETWEEN {} AND {}\",\n \"), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n > 0:\",\n \"elem in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {},\",\n \"the mean encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message\",\n \"\\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\":\",\n \"to use to aggregate the data. count : Number of elements. density :\",\n \"{} FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias,\",\n \"self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step\",\n \"\\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2]\",\n \"is date like). The vColumn will be transformed. Parameters ---------- field: str The\",\n \"for item in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3))\",\n \"({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS index, non_events, events,\",\n \"ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE\",\n \": Rose chart. It can also be a cutomized aggregation (ex: AVG(column1) +\",\n \"Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None,\",\n \"the data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\"\",\n \"optional Offset. Returns ------- tablesample An object containing the result. For more information,\",\n \"the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law\",\n \"= \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func:\",\n \"vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn to use\",\n \"IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n\",\n \"LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types(\",\n \"be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias\",\n \"{} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting\",\n \"(isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if\",\n \"[], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations = ( parent,\",\n \"the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble\",\n \"h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) ||\",\n \"\\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\") else\",\n \"included. right: bool, optional How the intervals should be closed. If set to\",\n \") custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ]\",\n \": approximative cardinality count : number of non-missing elements cvar : conditional value\",\n \"parent and do not apply it. This parameter is very useful for testing\",\n \"'\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has\",\n \"self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str\",\n \"the different transformations. \\\"\\\"\\\" # # Special Methods # # ---# def __init__(\",\n \"see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table.\",\n \"--------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters ---------- method: str, optional Method\",\n \"record of the vColumn. The vColumn will be transformed. Parameters ---------- pat: str\",\n \"used to cut the vColumn. labels: list, optional Labels used to name the\",\n \"# ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The\",\n \"ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", )\",\n \"optional The method to use to aggregate the data. count : Number of\",\n \"get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT\",\n \"\\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\",\",\n \"If empty, an optimized number of bins will be computed. h: float, optional\",\n \"vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\",\n \"self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the equal\",\n \"with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode :\",\n \"robust_zscore : Normalization using the Robust Z-Score (median and mad). (x - median)\",\n \"round(h, 4) elif h > 0.000001: h = round(h, 6) if self.category() ==\",\n \"vDataFrame[].date_part : Extracts a specific TS field from the vColumn. \\\"\\\"\\\" check_types( [\",\n \"schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\")\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\\",\n \"\\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\",\",\n \"index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0]\",\n \"WHEN {} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\",\",\n \"), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format(\",\n \"In this case, the parameter 'numcol' must be defined. numerical : Uses popular\",\n \"logarithm mod : remainder of a division operation pow : number raised to\",\n \"'labels' must be empty.\\\" ) conditions, column = [], self.alias for idx in\",\n \"\\\"float\\\", ) ] else: warning_message = \\\"Can not normalize {} using a Robust\",\n \"equals to 2 in case of discretization using the method 'topk'\\\" ) distinct\",\n \"Returns the n smallest elements in the vColumn. Parameters ---------- n: int, optional\",\n \"2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"),\",\n \"use to sort the data when using TS methods. Returns ------- vDataFrame self.parent\",\n \") method = method.lower() if self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"]\",\n \"delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was\",\n \"dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format(\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ----------\",\n \"optional Catalog where each key corresponds to an aggregation. vColumns will memorize the\",\n \"{}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to\",\n \"is greater than November 1993 the 3rd. plot_median: bool, optional If set to\",\n \"result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result =\",\n \"(float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\")\",\n \"parameter to False, the function's performance can drastically decrease. Returns ------- float quantile\",\n \"\\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return \\\"({} -\",\n \"Returns the vColumn expected store usage (unit: b). Returns ------- int vColumn expected\",\n \"by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\",\",\n \"the TS. start_date: str / date, optional Input Start Date. For example, time\",\n \"-------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]),\",\n \"method. Parameters ---------- method: str, optional Method to use to fill the vColumn\",\n \"\\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self):\",\n \"alias, [elem for elem in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\":\",\n \"See Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail :\",\n \"else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} ||\",\n \"if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}'\",\n \"] # ---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75),\",\n \": mode (most occurent element). 0ifnull : 0 when the vColumn is null,\",\n \"same_width : Computes regular width bins. smart : Uses the Random Forest on\",\n \"columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider\",\n \"be considered during the computation. Returns ------- tablesample An object containing the result.\",\n \"vColumn labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [\",\n \"\\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {}\",\n \"search. Parameters ---------- val: list List of the different records. For example, to\",\n \": median min : minimum mode : most occurent element percent : percent\",\n \"doesn't allow slicing having steps different than 1.\\\" ) index_stop = index.stop index_start\",\n \"return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else\",\n \"best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h\",\n \"user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode :\",\n \"return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int = 10):\",\n \"query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0]\",\n \": Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def\",\n \"0.01: h = round(h, 2) elif h > 0.0001: h = round(h, 4)\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\\",\n \"than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers\",\n \"cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn\",\n \"numerical. q: tuple, optional Tuple including the 2 quantiles used to draw the\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list, labels: list =\",\n \"= 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ----------\",\n \"self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except:\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {}\",\n \"self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0\",\n \"item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], } return tablesample(values)\",\n \"optional If set to True, the record will be sliced using the floor\",\n \"in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for\",\n \"the vColumn by keeping only the input number of digits after the comma.\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if\",\n \"be similar to the following: (function, type, category) parent: vDataFrame, optional Parent of\",\n \": Draws the Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str)\",\n \"\\\"\\\", h: float = 0, max_cardinality: int = 8, cat_priority: list = [],\",\n \"return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\",\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(),\",\n \"the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True if\",\n \"\\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL\",\n \"< 50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT\",\n \"will look like: even: CASE ... WHEN vColumn = argv[2 * i] THEN\",\n \"vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode\",\n \"\\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] ) if func not in\",\n \"\\\\ / / / # \\\\_______/ / / # ______ / / #\",\n \"self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {} FROM (SELECT {} AS\",\n \"Plot. step: bool, optional If set to True, draw a Step Plot. ax:\",\n \"result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise\",\n \"if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = []\",\n \"if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method ==\",\n \"distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY\",\n \"the discretization (must be > 1) k: int, optional The integer k of\",\n \"= \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True, alpha: float =\",\n \"by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]),\",\n \"self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for\",\n \"self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name,\",\n \"in the vColumn. Parameters ---------- threshold: float, optional Uses the Gaussian distribution to\",\n \"discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE\",\n \"Computes the Information Value (IV) / Weight Of Evidence (WOE) Table. It tells\",\n \"\\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\":\",\n \"\\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] ) if\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var See\",\n \"if the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category\",\n \"tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime,\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar\",\n \"will be updated when the parent vDataFrame is modified. Attributes ---------- alias, str\",\n \"\\\"minmax\\\": if n == 0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias]\",\n \"Adds the input element to the vColumn. Parameters ---------- x: float If the\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg\",\n \"quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method\",\n \") self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self,\",\n \"[int, float])]) if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title\",\n \"with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(),\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1: try: result =\",\n \"dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers\",\n \"approx: bool, optional If set to True, the approximate median is returned. By\",\n \"\\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def\",\n \"executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False,\",\n \"vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn\",\n \"!= 0, Exception( \\\"Not enough values to compute the Equal Frequency discretization\\\" )\",\n \"is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1)\",\n \"(\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\")\",\n \"as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str =\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular\",\n \"\\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev\",\n \"= \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) #\",\n \"[int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int\",\n \"vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" )\",\n \"float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"elements to display. offset: int, optional Number of elements to skip. Returns -------\",\n \"area: bool = False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"sum std : standard deviation topk : kth most occurent element (ex: top1\",\n \"result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert\",\n \"Random Forest model parameters used to compute the best splits when 'method' is\",\n \"Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])])\",\n \"(\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias:\",\n \"the final generated SQL code. Note: Dropping a vColumn can make the vDataFrame\",\n \"and a maximum depth of 10. response: str, optional Response vColumn when method\",\n \"\\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn =\",\n \"Filters the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return\",\n \"geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check =\",\n \"bijection from the different categories to [0, n - 1] (n being the\",\n \"* {} || ';' || (FLOOR({} / {}) * {} + {}{}) ||\",\n \"USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose() agg = aggregate\",\n \"= \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only\",\n \"find the most relevant interval to use for the discretization. topk : Keeps\",\n \"to be used as categorical. The less frequent elements will be gathered together\",\n \"optional Uses the threshold instead of the 'alpha' parameter. alpha: float, optional Number\",\n \"the current axes. ax: Matplotlib axes object, optional The axes to plot on.\",\n \"\\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else:\",\n \"mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters\",\n \"var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var\",\n \"Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert\",\n \"aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation). Returns -------\",\n \"otherwise. Returns ------- bool True if the vColumn is boolean. See Also --------\",\n \"transformations. Each transformation must be similar to the following: (function, type, category) parent:\",\n \"to {}\\\".format( e, self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method: str = \\\"density\\\",\",\n \"See Also -------- vDataFrame.donut : Draws the donut chart of the vColumn based\",\n \"max, median, unique... depending on the input method. Parameters ---------- method: str, optional\",\n \"VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query,\",\n \"to in writing, software # distributed under the License is distributed on an\",\n \"NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query\",\n \"\\\"Length of parameter breaks must be equal to the length of parameter 'labels'\",\n \"the data. The vColumn type must be date like (date, datetime, timestamp...) or\",\n \"), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method ==\",\n \"vColumns 1 and 2 bars. It is only valid if the vColumns are\",\n \"cardinality count : number of non-missing elements cvar : conditional value at risk\",\n \"{}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\",\",\n \"most relevant interval to use for the discretization. topk : Keeps the topk\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x !=\",\n \"elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN\",\n \"model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result =\",\n \"4.0, use_threshold: bool = True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops\",\n \"input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY\",\n \"most occurent element (ex: top1 for the mode) topk_percent : kth most occurent\",\n \"{}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing\",\n \"nullifzero, n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on\",\n \"\\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY\",\n \"stddev == 0: warning_message = \\\"Can not normalize {} using a Z-Score -\",\n \"/ date, optional Input Start Date. For example, time = '03-11-1993' will filter\",\n \"[int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x))\",\n \"vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn.\",\n \"the vColumn distinct elements to be used as categorical (No h will be\",\n \"Exception as e: self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error\",\n \"delimitor of the dummies. drop_first: bool, optional Drops the first dummy to avoid\",\n \"h: float, optional The interval size to convert to use to convert the\",\n \"---# def topk(self, k: int = -1, dropna: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {} WHERE {}\",\n \"categories will be filtered. ax: Matplotlib axes object, optional The axes to plot\",\n \"DOQ / DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column\",\n \"AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query, ) title =\",\n \"/ {} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int,\",\n \"> 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]:\",\n \"mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def fillna(\",\n \"= \\\"\\\", max_cardinality: int = 6, h: float = 0, pie_type: str =\",\n \"the lowest element of the list will be included. right: bool, optional How\",\n \": Percentage of the distribution. mean : Average of the vColumn 'of'. min\",\n \"1)) floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h >\",\n \"use_threshold: bool = True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers\",\n \"kwargs: column = kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column =\",\n \"will be filtered. ax: Matplotlib axes object, optional The axes to plot on.\",\n \"display. offset: int, optional Number of elements to skip. Returns ------- tablesample An\",\n \"\\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a\",\n \"idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5],\",\n \"result, } if ((is_date) and not (method == \\\"categorical\\\")) or ( method ==\",\n \") return self.parent # ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\",\",\n \"self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x:\",\n \"most occurent elements to return. Returns ------- tablesample An object containing the result.\",\n \"bound itself and the values higher than the upper bound to the upper\",\n \"\\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the\",\n \"END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type.\",\n \"\\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"',\",\n \"VerticaPy brings the logic to the data. # # # Modules # #\",\n \"self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(),\",\n \"the License is distributed on an \\\"AS IS\\\" BASIS, # WITHOUT WARRANTIES OR\",\n \"pie chart. donut : Donut chart. rose : Rose chart. It can also\",\n \"number round : rounds a value to a specified number of decimal places\",\n \"a function to the vColumn. Parameters ---------- func: str, Function in pure SQL\",\n \"(schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert\",\n \"governing permissions and # limitations under the License. # # |_ |~) _\",\n \"of the record is greater than the threshold it will be considered as\",\n \"self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self, x: float, approx: bool =\",\n \"ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\",\",\n \"outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped.\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut\",\n \"during the computation. Returns ------- tablesample An object containing the result. For more\",\n \"using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True, the\",\n \"to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"),\",\n \"(n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {},\",\n \"empty, an optimized h will be computed. pie_type: str, optional The type of\",\n \"---# def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most\",\n \"result[i] ) trans += \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\")\",\n \"using a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the\",\n \"( \\\"WHEN {} > {} THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float,\",\n \"style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4,\",\n \"< 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias)\",\n \"plot on. **style_kwds Any optional parameter to pass to the Matplotlib functions. Returns\",\n \"not be converted to {}\\\".format( e, self.alias, dtype ) ) # ---# def\",\n \"vDataFrame[].isdate : Returns True if the vColumn category is date. vDataFrame[].isnum : Returns\",\n \"ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date:\",\n \"optional Integer corresponding to the offset. For example, if n = 1 then\",\n \"name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy\",\n \"method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp\",\n \"xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return\",\n \"use to partition the TS. start_date: str / date, optional Input Start Date.\",\n \"Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1]\",\n \"AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \"vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date =\",\n \"see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn to the\",\n \"/ YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the\",\n \"dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"vColumn 'of'. max : Maximum of the vColumn 'of'. sum : Sum of\",\n \"approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns\",\n \"the approximate density function. Increasing this parameter will increase the precision but will\",\n \"standard error of the mean skewness : skewness sum : sum std :\",\n \"self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns\",\n \"Value to use to impute the vColumn. method: dict, optional Method to use\",\n \"log : logarithm log10 : base 10 logarithm mod : remainder of a\",\n \"varchar. same_freq : Computes bins with the same number of elements. same_width :\",\n \"For example to apply the function: x -> x^2 + 2 use \\\"POWER({},\",\n \"0 when the vColumn is null, 1 otherwise. expr: str, optional SQL expression.\",\n \"(method == \\\"mode\\\") and (val == None): val = self.mode(dropna=True) if val ==\",\n \"FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev\",\n \"category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total\",\n \"hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor : value\",\n \"== 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else:\",\n \"method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]):\",\n \"vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns\",\n \"[self.max()] elif method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must\",\n \"n = \\\"\\\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top\",\n \"n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"by an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])])\",\n \"optional New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies\",\n \"vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew\",\n \"vColumns used in the partition. order_by: list, optional List of the vColumns to\",\n \"self, method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True,\",\n \"-------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n,\",\n \"method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower !=\",\n \"the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use to\",\n \"vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by, str):\",\n \"average absolute deviation approx_unique : approximative cardinality count : number of non-missing elements\",\n \"timestamp...) or numerical. by: str, optional vColumn to use to partition the TS.\",\n \"start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"**kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args / **kwargs Any\",\n \"determine if the vColumn will be considered as categorical. numcol: str, optional Numerical\",\n \"2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func:\",\n \"* FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL\",\n \"}, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features\",\n \"), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column\",\n \"'unique' (cardinality). Parameters ---------- approx: bool, optional If set to True, the approximate\",\n \"use for the discretization. topk : Keeps the topk most frequent categories and\",\n \"\\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0}\",\n \"2 bars. It is only valid if the vColumns are numerical. Optimized h\",\n \"10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE)\",\n \"if elem[2] != None else \\\"NULL\\\", ) for elem in result if elem[2]\",\n \"optional The vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix\",\n \"NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category =\",\n \"x -> x^2 + 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional\",\n \"if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} <\",\n \"elif method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must be\",\n \"[ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\",\",\n \"of pie chart. auto : Regular pie chart. donut : Donut chart. rose\",\n \"\\\"The vColumn {} has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias )\",\n \"absolute deviation max : maximum mean : average median : median min :\",\n \"all of the above. The idea is simple: instead of moving # data\",\n \"method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()]\",\n \"the data. method: str, optional The method to use to aggregate the data.\",\n \"---------- by: str, optional vColumn to use to partition the data. method: str,\",\n \"the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of the\",\n \"the vColumn from the vDataFrame. Dropping a vColumn means simply not selecting it\",\n \"by dropping the current vColumn and creating a copy with the specified name.\",\n \"# # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all\",\n \"of the bar. If empty, an optimized h will be computed. pie_type: str,\",\n \"to do all of the above. The idea is simple: instead of moving\",\n \"having steps different than 1.\\\" ) index_stop = index.stop index_start = index.start if\",\n \"to look at the final transformation. Returns ------- vDataFrame self.parent See Also --------\",\n \": arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt :\",\n \"be used as categorical. The less frequent elements will be gathered together to\",\n \"{}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count =\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized expression.\",\n \"val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val}\",\n \"optional The interval size to convert to use to convert the vColumn. If\",\n \"One hot encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features),\",\n \"by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format(\",\n \"SQL used to transform the vColumn. The function variable must be composed of\",\n \": Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\",\",\n \"if isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column =\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with a\",\n \"self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias]\",\n \"\\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int,\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by: str,\",\n \"method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias,\",\n \"(the \\\"License\\\"); # You may not use this file except in compliance with\",\n \"must be a vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric,\",\n \"method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name\",\n \") transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent,\",\n \"otherwise it will represent a number. Returns ------- vDataFrame self.parent See Also --------\",\n \"See Also -------- vDataFrame[].fill_outliers : Fills the vColumn outliers using the input method.\",\n \"def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions.\",\n \"result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem\",\n \"int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent element. Parameters ----------\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int\",\n \"h: float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {})\",\n \"[\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method =\",\n \"self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles\",\n \"(SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias,\",\n \"nbins. If empty, an optimized number of nbins will be computed. h: float,\",\n \"in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max(\",\n \"(self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias of one of the dummies\",\n \"sem See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in\",\n \"{}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int):\",\n \"title=title) # ---# def normalize( self, method: str = \\\"zscore\\\", by: list =\",\n \"to discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast\",\n \"return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory\",\n \"Any amount of expressions. The expression generated will look like: even: CASE ...\",\n \"== \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column\",\n \"pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns\",\n \"pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also\",\n \"response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {},\",\n \"nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins\",\n \"best_h # ---# def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn category is\",\n \"q: tuple, optional Tuple including the 2 quantiles used to draw the Plot.\",\n \"return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str = \\\"\\\", bandwidth:\",\n \"iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad :\",\n \"= self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func 'x\",\n \"step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"= val # # Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"increase the precision but will also increase the time of the learning and\",\n \"cut the vColumn. labels: list, optional Labels used to name the new categories.\",\n \"# ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool = True,\",\n \"else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str = \\\"density\\\", of:\",\n \"self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max\",\n \"numerical. Optimized h will be computed if the parameter is empty or invalid.\",\n \"= gen_colors() if not xlim: xmin = self.min() xmax = self.max() else: xmin,\",\n \"(except ints and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\":\",\n \"k: int, optional Number of most occurent elements to return. Returns ------- tablesample\",\n \"model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias],\",\n \"\\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias,\",\n \"to the next whole number cos : trigonometric cosine cosh : hyperbolic cosine\",\n \"[list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot\",\n \"None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ----------\",\n \"Parameters ---------- method: str, optional Method to use to fill the vColumn outliers.\",\n \"(\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] )\",\n \"on the input method. Parameters ---------- method: str, optional The describe method. auto\",\n \"/ / # |____/ / / # _____________ / / # \\\\ /\",\n \"executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0]\",\n \"vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn\",\n \"nbins if h > 0.01: h = round(h, 2) elif h > 0.0001:\",\n \"labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1}\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset\",\n \"transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str, optional New\",\n \"BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i\",\n \"\\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\\",\n \"decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate\",\n \"vColumn records. vDataFrame[].str_count : Computes the number of matches for the regular expression\",\n \"\\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return\",\n \"{} WHEN {} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha,\",\n \"# ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns -------\",\n \"the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be\",\n \"be closed on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \"== 0: warning_message = \\\"Can not normalize {} using the MIN and the\",\n \"if the vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is\",\n \"Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot\",\n \"aggregate the data. count : Number of elements. density : Percentage of the\",\n \"Warning) return self elif method == \\\"minmax\\\": if n == 0: nullifzero =\",\n \"category : 'Others'. cat_priority: list, optional List of the different categories to consider\",\n \"utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\"\",\n \") method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by)\",\n \"1] if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else:\",\n \"/ MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE\",\n \"2 quantiles used to draw the Plot. start_date: str / date, optional Input\",\n \": Fills the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float,\",\n \"((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\")) or not (is_numeric) or\",\n \"digits after the comma. Parameters ---------- n: int Number of digits to keep\",\n \"desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({}\",\n \": Normalization using the MinMax (min and max). (x - min) / (max\",\n \"\\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\",\",\n \"check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime,\",\n \"sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in\",\n \"Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias:\",\n \"'new_name', you'll be able to solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False)\",\n \"Replaces the regular expression matches in each of the vColumn records by an\",\n \"= \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events,\",\n \"BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna,\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an\",\n \"e: raise QueryError( \\\"{}\\\\nError when applying the func 'x -> {}' to '{}'\\\".format(\",\n \"cvar : conditional value at risk dtype : vColumn type iqr : interquartile\",\n \"-------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by\",\n \"Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"# ---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the\",\n \"= \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for\",\n \"= str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types(\",\n \"method. Parameters ---------- method: str, optional The method to use to discretize the\",\n \"0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE\",\n \"int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ----------\",\n \"-------- vDataFrame[].str_contains : Verifies if the regular expression is in each of the\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot of the input vColumn based on\",\n \"ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel\",\n \"\\\"count\\\"] + [item[0] for item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\",\",\n \"\\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"),\",\n \"of the distribution. mean : Average of the vColumn 'of'. min : Minimum\",\n \"float A float between 0 and 1 that represents the quantile. For example:\",\n \"can drastically decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes\",\n \"( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero)\",\n \"See the License for the specific language governing permissions and # limitations under\",\n \"following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search. See\",\n \"= [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h,\",\n \"val = self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn {} has\",\n \"[int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return\",\n \"* {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h,\",\n \"\\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds,\",\n \"= (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans] sauv\",\n \"of the different aggregation. aad : average absolute deviation approx_unique : approximative cardinality\",\n \"if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] )\",\n \"mean : average median : median min : minimum mode : most occurent\",\n \"NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing the parameter 'name', you'll\",\n \"values = to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method\",\n \"--------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int, optional Number\",\n \"\\\"Can not normalize {} using a Robust Z-Score - The MAD is null\",\n \"if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__(\",\n \"5). ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"str, optional Method to use to fill the vColumn outliers. mean : Replaces\",\n \"optional Dictionary of the Random Forest model parameters used to compute the best\",\n \"axes object See Also -------- vDataFrame.donut : Draws the donut chart of the\",\n \"} for elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index):\",\n \"the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \"True if the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---#\",\n \"records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int,\",\n \"= 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem\",\n \"Uses method 'same_width' for numerical vColumns, cast the other types to varchar. same_freq\",\n \"x)) # ---# def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()),\",\n \"normalizing the data (Z-Score), if the absolute value of the record is greater\",\n \"2, TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) response_cat =\",\n \"learning features. It supports the # entire data science life cycle, uses a\",\n \"The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs):\",\n \"pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826\",\n \"iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn\",\n \"and machine learning features. It supports the # entire data science life cycle,\",\n \"{}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ), \\\"float\\\",\",\n \"If not empty, a copy will be created using the input Name. Returns\",\n \"\\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int = 5): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"if not (dropna): n = \\\"\\\" if (n == 1) else str(int(n)) if\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ---------- method:\",\n \"self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format(\",\n \"---------- lower: float, optional Lower bound. upper: float, optional Upper bound. Returns -------\",\n \"100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent,\",\n \"------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])]\",\n \"[int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\"\",\n \"in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"[ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h,\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset and\",\n \"column for each vColumn category. In this case, the parameter 'numcol' must be\",\n \"if the parameter is empty or invalid. max_cardinality: int, optional Maximum number of\",\n \"= \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp = [xlim]\",\n \"(No h will be picked or computed) nbins: int, optional Number of nbins.\",\n \"var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \") distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({}) THEN\",\n \"vColumn. Parameters ---------- func: str, Function in pure SQL used to transform the\",\n \"\\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort()\",\n \"= \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"n = len(result) trans = \\\"(CASE \\\" for i in range(1, n): trans\",\n \"return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the\",\n \"if the vDataFrame has been transformed multiple times, so it's better practice to\",\n \"i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT\",\n \"str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT\",\n \"[]: if fun == \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val\",\n \"# ---# def numh(self, method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal\",\n \".transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4],\",\n \"vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper,\",\n \"Slices and transforms the vColumn using a time series rule. Parameters ---------- length:\",\n \"like). The vColumn will be transformed. Parameters ---------- field: str The field to\",\n \"with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else:\",\n \"1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0\",\n \"different vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame self.parent\",\n \"str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of\",\n \"the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk\",\n \"q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\",\",\n \"= get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL\",\n \"successfully done.\\\") return self.parent # ---# def median( self, approx: bool = True,\",\n \"method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad\",\n \"in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], } return tablesample(values) #\",\n \"{}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem]\",\n \"optional Interval width of the vColumns 1 and 2 bars. It is only\",\n \"base 10 logarithm mod : remainder of a division operation pow : number\",\n \"\\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn)\",\n \"the regular expression is in each of the vColumn records. vDataFrame[].str_count : Computes\",\n \"= [by] if isinstance(order_by, str): order_by = [order_by] check_types( [ ( \\\"method\\\", method,\",\n \"a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a\",\n \"product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"= ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER\",\n \"= ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts:\",\n \"in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif\",\n \"self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count] + result\",\n \"0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram\",\n \") # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average).\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length: int, unit:\",\n \"the vColumn. vDataFrame[].extract : Extracts the regular expression in each record of the\",\n \"else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 *\",\n \"re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except:\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors\",\n \"sublist] # ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by\",\n \"order_by] + by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\"\",\n \"is lesser than November 1993 the 3rd. end_date: str / date, optional Input\",\n \"each of the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int,\",\n \"] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {},\",\n \"so it's better practice to use this method when first preparing your data.\",\n \"than the threshold it will be considered as an outlier. use_threshold: bool, optional\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"== 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\"\",\n \"index_stop += self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit\",\n \"(\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]),\",\n \"= \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total = self.count()\",\n \"# ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is\",\n \"\\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for\",\n \"] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax, cmin,\",\n \"the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), (\",\n \"if len(args) > 0: column = args[0] elif \\\"column\\\" in kwargs: column =\",\n \"if the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns True\",\n \"if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"It supports the # entire data science life cycle, uses a ‘pipeline’ mechanism\",\n \"numerical for Normalization\\\") return self.parent # ---# def nsmallest(self, n: int = 10):\",\n \"a Robust Z-Score - The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"+= [(new_column, ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem]\",\n \"------- tablesample An object containing the result. For more information, see utilities.tablesample. See\",\n \"= [], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns\",\n \"method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), )\",\n \"Returns ------- bool True if the vColumn category is date. See Also --------\",\n \"width if the vColumn is numerical or of type date like. Optimized h\",\n \"/ ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not\",\n \"{}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\",\",\n \"\\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({})\",\n \"filtered. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"/ / # | \\\\/ / / / # |______ / / /\",\n \"use to fill the vColumn outliers. mean : Replaces the upper and lower\",\n \") self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent #\",\n \"[elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor:\",\n \"FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT {} AS index, non_events,\",\n \"elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"example, time = '03-11-1993' will filter the data when 'ts' is lesser than\",\n \"\\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if (by) else\",\n \"to evaluate the approximate density function. Increasing this parameter will increase the precision\",\n \"title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---#\",\n \"self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number\",\n \"column in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))),\",\n \"== 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0:\",\n \"updated when the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn\",\n \"self.alias, self.alias, ) else: query = \\\"SELECT {} FROM (SELECT {} AS {},\",\n \"{}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return self.parent except Exception as e:\",\n \"= self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({}) THEN {} ||\",\n \"'by' is empty\\\\nIf you want to normalize by grouping by elements, please use\",\n \"bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to False\",\n \"+= \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations\",\n \"<= 0: h = self.numh() else: h = (self.max() - self.min()) * 1.01\",\n \"return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str =\",\n \"vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum number of\",\n \"isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\",\",\n \"to extract. It must be one of the following: CENTURY / DAY /\",\n \"Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"ANY KIND, either express or implied. # See the License for the specific\",\n \"= self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format(\",\n \"vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\"\",\n \"the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn category is\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\"\",\n \": vColumn type iqr : interquartile range kurtosis : kurtosis jb : Jarque-Bera\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel,\",\n \"and (method != \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ): query\",\n \"approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters\",\n \"alias of one of the dummies ({name}).\\\\n\\\" \\\"It can be the result of\",\n \"GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"],\",\n \"Encodes the vColumn using the average of the response partitioned by the different\",\n \"precision but will also increase the time of the learning and scoring phases.\",\n \"Computes regular width bins. smart : Uses the Random Forest on a response\",\n \"categories of the vColumn. Returns ------- list Distinct caterogies of the vColumn. See\",\n \"= self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={\",\n \"by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime,\",\n \"cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category\",\n \"\\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item in\",\n \"\\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT {}\",\n \"[bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on numerical\",\n \"response: str, optional Response vColumn when method is set to 'smart'. return_enum_trans: bool,\",\n \") # ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression\",\n \"( \\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float,\",\n \"= [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format =\",\n \"nbins: int, optional Number of nbins. If empty, an optimized number of nbins\",\n \"skewness : skewness sum : sum std : standard deviation topk : kth\",\n \"optional Input Start Date. For example, time = '03-11-1993' will filter the data\",\n \"vColumn has already the alias of one of the dummies ({name}).\\\\n\\\" \\\"It can\",\n \"NULL value. winsorize : Clips the vColumn using as lower bound quantile(alpha) and\",\n \"# ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of\",\n \"if n = 1 then this method will return the mode of the\",\n \"if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1]\",\n \"= 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the\",\n \"because of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'),\",\n \"parameters ('prefix', 'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\" ) for\",\n \"element. Parameters ---------- x: float Input number. Returns ------- vDataFrame self.parent See Also\",\n \"if limit <= 0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else:\",\n \"distinct) var : variance Other aggregations could work if it is part of\",\n \"0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop\",\n \"for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1]\",\n \"the data (Z-Score), if the absolute value of the record is greater than\",\n \"values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by =\",\n \"average of the response partitioned by the different vColumn categories. Parameters ---------- response:\",\n \"\\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step: bool\",\n \"the top{} categories of {}.\\\".format( k if k > 0 else \\\"\\\", self.alias\",\n \"AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title\",\n \"Encoding]: Label Encoding was applied to the vColumn {} using the following mapping:{}\\\".format(\",\n \"cmin == 0: warning_message = \\\"Can not normalize {} using the MIN and\",\n \"e, self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"\\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search. See Also -------- vDataFrame.isin\",\n \"was transformed using a mean encoding with {} as Response Column.\\\".format( self.alias, response\",\n \"optional The axes to plot on. **style_kwds Any optional parameter to pass to\",\n \"/ {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin,\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] #\",\n \"= \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(),\",\n \"utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types(\",\n \") if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\",\",\n \"all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0] variance =\",\n \"--------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent\",\n \"Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix\",\n \"time = '03-11-1993' will filter the data when 'ts' is greater than November\",\n \"vColumn is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\"\",\n \"limit = index_stop - index_start if limit <= 0: limit = 0 limit\",\n \"nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop()\",\n \"naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to\",\n \"BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count\",\n \"your data. Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame\",\n \"self.transformations = [elem for elem in copy_trans] for elem in sauv: self.catalog[elem] =\",\n \"{}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories to\",\n \"the missing values. auto : Mean for the numerical and Mode for the\",\n \"self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with\",\n \"# ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns -------\",\n \"\\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot(\",\n \"\\\"{}\\\\nError when applying the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"-------- vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])])\",\n \"self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor,\",\n \"except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent #\",\n \"Parent of the vColumn. One vDataFrame can have multiple children vColumns whereas one\",\n \"the lower bound to the lower bound itself and the values higher than\",\n \"(by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in\",\n \"cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER\",\n \"format = 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"]) ] query =\",\n \"parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog, dict\",\n \"in relation to the dependent variable. Parameters ---------- y: str Response vColumn. nbins:\",\n \"Subtracts the input element from the vColumn. Parameters ---------- x: float If the\",\n \"param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column)\",\n \"is boolean, False otherwise. Returns ------- bool True if the vColumn is boolean.\",\n \"better practice to use this method when first preparing your data. Parameters ----------\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit: int\",\n \"limit). Parameters ---------- limit: int, optional Number of elements to display. offset: int,\",\n \"plot of the vColumn. Parameters ---------- by: str, optional vColumn to use to\",\n \"\\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__|\",\n \"= 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query =\",\n \"If empty, names will be generated. include_lowest: bool, optional If set to True,\",\n \"Python library with scikit-like functionality for conducting # data science projects on data\",\n \"labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column}\",\n \"the response is numerical (except ints and bools), a RF Classifier otherwise. Example:\",\n \"Parameters ---------- val: int/float/str, optional Value to use to impute the vColumn. method:\",\n \"example to apply the function: x -> x^2 + 2 use \\\"POWER({}, 2)\",\n \"Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1 /\",\n \"== \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method ==\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information\",\n \"a vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date =\",\n \"columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations = [elem\",\n \"[\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result #\",\n \"prod = product # ---# def quantile(self, x: float, approx: bool = True):\",\n \"x limits of the current axes. ax: Matplotlib axes object, optional The axes\",\n \"= self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method,\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"statistical aggregations: min, max, median, unique... depending on the input method. Parameters ----------\",\n \"distinct elements to be used as categorical (No h will be picked or\",\n \"threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha\",\n \"The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def\",\n \"from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step,\",\n \"_____________ / / # \\\\ / / / # \\\\ / / /\",\n \"function has two arguments (example, power or mod), 'x' represents the second argument.\",\n \"will be computed. nbins: int, optional Number of bins used for the discretization\",\n \"for column in by]) ) if (by) else \\\"\\\" ) order_by_ts = \\\",\",\n \"See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\",\",\n \", 'categorical' otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats\",\n \": Donut chart. rose : Rose chart. It can also be a cutomized\",\n \"...), the parameter 'x' will represent the number of seconds, otherwise it will\",\n \"the input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]),\",\n \"k: int, optional Number of most occurent elements to return. dropna: bool, optional\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the vColumn.\",\n \"NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER\",\n \"{} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format(\",\n \"---------- approx: bool, optional If set to True, the approximate median is returned.\",\n \"'of'. min : Minimum of the vColumn 'of'. max : Maximum of the\",\n \"the computation. max_cardinality: int, optional Cardinality threshold to use to determine if the\",\n \"the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\"\",\n \"\\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE\",\n \"val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val)\",\n \"in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the\",\n \"== 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev ==\",\n \"value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each\",\n \"'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical : Uses only\",\n \"= len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations =\",\n \"writing, software # distributed under the License is distributed on an \\\"AS IS\\\"\",\n \"defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes\",\n \"Uses the Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if\",\n \"\\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column\",\n \"[ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\",\",\n \"bound quantile(1-alpha) if 'use_threshold' is set to False else the lower and upper\",\n \"object See Also -------- vDataFrame.boxplot : Draws the Box Plot of the input\",\n \"a ‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful graphical\",\n \"--------------------------------------------------------------------------- Converts the vColumn to the input type. Parameters ---------- dtype: str New\",\n \"{self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if\",\n \"The vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum number\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV)\",\n \"[elem for elem in self.transformations] total = self.count() if method not in [\\\"mode\\\",\",\n \"most occurent element. Parameters ---------- dropna: bool, optional If set to True, NULL\",\n \"def mode(self, dropna: bool = False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"\\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response\",\n \"See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys\",\n \"self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\",\",\n \"limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias,\",\n \"[str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"],\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"the parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations during\",\n \"categories. If empty, names will be generated. include_lowest: bool, optional If set to\",\n \"using the MinMax (min and max). (x - min) / (max - min)\",\n \"MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER\",\n \"(self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the parameter 'new_name',\",\n \"numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [],\",\n \"# # ---# def __init__( self, alias: str, transformations: list = [], parent=None,\",\n \"True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool,\",\n \"threshold instead of the 'alpha' parameter. alpha: float, optional Number representing the outliers\",\n \"compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result\",\n \"parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple children\",\n \"\\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\",\",\n \"ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a list\",\n \"will be picked or computed) nbins: int, optional Number of nbins. If empty,\",\n \"Method to use to fill the vColumn outliers. mean : Replaces the upper\",\n \"transformations: list, optional List of the different transformations. Each transformation must be similar\",\n \"Clips the vColumn by transforming the values lesser than the lower bound to\",\n \"stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n >\",\n \"\\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\"\",\n \"the predictive power of an independent variable in relation to the dependent variable.\",\n \"h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method,\",\n \"= { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, }\",\n \"'aad' (Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate :\",\n \"= len(result) trans = \\\"(CASE \\\" for i in range(1, n): trans +=\",\n \"mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in\",\n \"optional Input End Date. For example, time = '03-11-1993' will filter the data\",\n \"Returns the k most occurent elements and their distributions as percents. Parameters ----------\",\n \"k most occurent elements, how often they occur, and other statistical information. Parameters\",\n \"1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION\",\n \"- self.min()) * 1.01 / nbins if h > 0.01: h = round(h,\",\n \"describe( self, method: str = \\\"auto\\\", max_cardinality: int = 6, numcol: str =\",\n \"return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not\",\n \"on the vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing one\",\n \"None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [\",\n \"List of the different categories to consider when drawing the box plot. The\",\n \"def plot( self, ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date]\",\n \"= 0, nbins: int = -1, k: int = 6, new_category: str =\",\n \"Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp\",\n \"k if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values =\",\n \"= \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using\",\n \"count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS\",\n \"(ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to plot\",\n \"), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method\",\n \"be considered as an outlier. use_threshold: bool, optional Uses the threshold instead of\",\n \"matches in each of the vColumn record by an input value. The vColumn\",\n \": Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self,\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total,\",\n \"\\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\",\",\n \"---# def hist( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"whereas one vColumn can only have one parent. catalog: dict, optional Catalog where\",\n \"vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\"\",\n \"else: if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0]\",\n \"'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else: result\",\n \"normalize {} using a Z-Score - The Standard Deviation is null !\\\".format( self.alias\",\n \"vDataFrame[].str_replace : Replaces the regular expression matches in each of the vColumn records\",\n \"relation, a vColumn can be seen as one column of that relation. vColumns\",\n \"for the numerical and Mode for the categorical vColumns. bfill : Back Propagation\",\n \"average. null : Replaces the outliers by the NULL value. winsorize : Clips\",\n \"getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return\",\n \"(dropna) else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100\",\n \"ALL \\\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing the optimized\",\n \"TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame\",\n \"< 0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {}\",\n \"(SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP\",\n \"str, optional vColumn to use to partition the data. bandwidth: float, optional The\",\n \"return. Returns ------- tablesample An object containing the result. For more information, see\",\n \"comma. Parameters ---------- n: int Number of digits to keep after the comma.\",\n \"(function, type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can\",\n \"pie_type == \\\"donut\\\" else False rose = True if pie_type == \\\"rose\\\" else\",\n \"If set to True, the method will return the transformation used instead of\",\n \"limit <= 0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit\",\n \"AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4})\",\n \": maximum mean : average median : median min : minimum mode :\",\n \"{})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {}\",\n \"in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func\",\n \"\\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\",\",\n \"query = \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias,\",\n \"def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn\",\n \"solve this issue.\\\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {}\",\n \"\\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self):\",\n \"**style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'.\",\n \"FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP\",\n \"parameter is empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct\",\n \"+ \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def range_plot( self, ts: str,\",\n \"\\\"auto\\\", expr: str = \\\"\\\", by: list = [], order_by: list = [],\",\n \"verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax,\",\n \"in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{}\",\n \"query, cat = [], self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\",\",\n \"\\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\":\",\n \"elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The\",\n \"\\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\":\",\n \"the partition. order_by: list, optional List of the vColumns to use to sort\",\n \"optional Maximum number of points to use to evaluate the approximate density function.\",\n \"self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\":\",\n \"+= [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result\",\n \"--------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ---------- ts: str TS\",\n \"/ ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH /\",\n \"\\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method !=\",\n \"Time Series of the vColumn. Parameters ---------- ts: str TS (Time Series) vColumn\",\n \"Optimized h will be computed if the parameter is empty or invalid. max_cardinality:\",\n \"float, optional Number representing the outliers threshold. Values lesser than quantile(alpha) or greater\",\n \"old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn\",\n \"otherwise. Returns ------- bool True if the vColumn is numerical. See Also --------\",\n \"TypeError( \\\"cut only works on numerical / date-like vColumns.\\\" ) assert len(breaks) >=\",\n \"h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns\",\n \"file except in compliance with the License. # You may obtain a copy\",\n \"on type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False\",\n \"print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun,\",\n \"[ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {}\",\n \"the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by,\",\n \"drop_first: bool, optional Drops the first dummy to avoid the creation of correlated\",\n \"/ ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"]\",\n \"0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE\",\n \"float, optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers :\",\n \"record will be sliced using the floor of the slicing instead of the\",\n \"False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time\",\n \"\\\\ / / / # \\\\ / / / # \\\\_______/ / /\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool =\",\n \"val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({},\",\n \"will represent a number. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"{1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \\\"UNION ALL\",\n \"method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for item in query_result] index\",\n \"check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start,\",\n \"the approximate quantile is returned. By setting this parameter to False, the function's\",\n \"transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations,\",\n \"else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in self.transformations]\",\n \"{}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha,\",\n \"Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first:\",\n \"the vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing one of\",\n \"self, method: str = \\\"auto\\\", h: float = 0, nbins: int = -1,\",\n \"Looks if some specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str)\",\n \"(6, 6), h: Union[int, float, tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] +\",\n \"elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT\",\n \"self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate\",\n \"[(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\":\",\n \"( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else:\",\n \"generated. include_lowest: bool, optional If set to True, the lowest element of the\",\n \"self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL(\",\n \"total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition\",\n \"range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1,\",\n \"vColumn expected store usage (unit: b). Returns ------- int vColumn expected store usage.\",\n \"_verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems + [str(count)]) ) query = \\\"SELECT\",\n \"in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\"\",\n \"vColumns used in the partition. return_trans: bool, optimal If set to True, the\",\n \"------- float/str maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"(\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if\",\n \"{} smallest elements.\\\".format(n, self.alias) return to_tablesample(query, title=title) # ---# def numh(self, method: str\",\n \"bar. If empty, an optimized h will be computed. pie_type: str, optional The\",\n \"0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\"\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\",\",\n \"using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate : Computes\",\n \"( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\"\",\n \"else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1\",\n \"the optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis :\",\n \"Exception as e: raise QueryError( \\\"{}\\\\nError when applying the func 'x -> {}'\",\n \"odd : CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 *\",\n \"# ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected store usage (unit:\",\n \"> 0.01: h = round(h, 2) elif h > 0.0001: h = round(h,\",\n \"for conducting # data science projects on data stored in Vertica, taking advantage\",\n \"---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0\",\n \"New value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if\",\n \"data when using TS methods. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna\",\n \"events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ())\",\n \"Returns the transformation instead of the vDataFrame parent and do not apply it.\",\n \"step)) # ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element\",\n \"new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the\",\n \"different transformations. \\\"\\\"\\\" # # Special Methods # # ---# def __init__( self,\",\n \"= [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name,\",\n \"[], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)]\",\n \"h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \\\"\\\", h:\",\n \"vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the\",\n \"1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\",\",\n \"for item in result], } return tablesample(values) # ---# def value_counts(self, k: int\",\n \"boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.category()\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}),\",\n \"\\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1)\",\n \"Multiplies the vColumn by the input element. Parameters ---------- x: float Input number.\",\n \"\\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if\",\n \"0: offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail =\",\n \"If set to True, the record will be sliced using the floor of\",\n \"of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if\",\n \"of nbins used for the discretization (must be > 1) Returns ------- tablesample\",\n \"self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\",\",\n \"features. It supports the # entire data science life cycle, uses a ‘pipeline’\",\n \"= \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS\",\n \") stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\",\",\n \"optional Method to use to compute the optimal h. auto : Combination of\",\n \"the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead\",\n \"cube root ceil : value up to the next whole number cos :\",\n \"null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and\",\n \"model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name =\",\n \"greater than November 1993 the 3rd. plot_median: bool, optional If set to True,\",\n \"except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations\",\n \"ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific\",\n \"{} named {} was added to the vDataFrame.\\\".format( self.alias, name ) ) return\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\",\",\n \"approximative cardinality count : number of non-missing elements cvar : conditional value at\",\n \"False, the function's performance can drastically decrease. Returns ------- int vColumn cardinality (or\",\n \"-------- vDataFrame.fill_outliers : Fills the outliers in the vColumn. vDataFrame.outliers : Adds a\",\n \"an optimized number of nbins will be computed. h: float, optional Interval width\",\n \"close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r = \\\"<=\\\",\",\n \"x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{}\",\n \"def iloc(self, limit: int = 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"element density unique : cardinality (count distinct) var : variance Other aggregations could\",\n \"vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], ) elif\",\n \"quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str\",\n \"new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See Also --------\",\n \"\\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result\",\n \"index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else: result =\",\n \"round(h, 6) if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0]\",\n \"can also be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional\",\n \"\\\"\\\", cmax, cmin, ) else: final_transformation = [ ( \\\"({} - {}) /\",\n \"[(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the vColumn. The aggregations used\",\n \"\\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\\",\n \"mad) minmax : Normalization using the MinMax (min and max). (x - min)\",\n \"of elements to display. Returns ------- tablesample An object containing the result. For\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset <\",\n \"0, an optimised interval will be computed. nbins: int, optional Number of bins\",\n \"merge the other into one unique category. h: float, optional The interval size\",\n \"pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations +=\",\n \"vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---#\",\n \"parent. catalog: dict, optional Catalog where each key corresponds to an aggregation. vColumns\",\n \"---# def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the\",\n \"if idx == 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx\",\n \"GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if\",\n \"Computes bins with the same number of elements. same_width : Computes regular width\",\n \"/\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\\",\n \"\\\"\\\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top)\",\n \") assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must be greater\",\n \"limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] =\",\n \"---# def density( self, by: str = \\\"\\\", bandwidth: float = 1.0, kernel:\",\n \"copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name =\",\n \") return self.parent # ---# def fillna( self, val=None, method: str = \\\"auto\\\",\",\n \"use to order the data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\",\",\n \"max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance).\",\n \"in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available for categorical variables.\\\"\",\n \"using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] except:\",\n \"/ DOQ / DOW / DOY / EPOCH / HOUR / ISODOW /\",\n \"nbins: int, optional Maximum number of nbins used for the discretization (must be\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis #\",\n \"distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix\",\n \"self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and self.nunique(True) >\",\n \"parent = self.drop(add_history=False) parent.__add_to_history__( \\\"[Rename]: The vColumn {} was renamed '{}'.\\\".format(old_name, new_name) )\",\n \"parameter is used for testing purpose. Returns ------- vDataFrame self.parent See Also --------\",\n \"will be generated. include_lowest: bool, optional If set to True, the lowest element\",\n \"= \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0],\",\n \"the upper and lower outliers by their respective average. null : Replaces the\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\"\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ---------- start:\",\n \": Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---#\",\n \"Draws the histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [\",\n \"'{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def spider( self, by:\",\n \"self.avg() elif fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val)\",\n \"Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query\",\n \"int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by]\",\n \"the function's performance can drastically decrease. Returns ------- float/str median See Also --------\",\n \"is boolean. vDataFrame[].isdate : Returns True if the vColumn category is date. \\\"\\\"\\\"\",\n \"/ MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND /\",\n \"(Constant Interpolation). mean : Average. median : median. mode : mode (most occurent\",\n \"[str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\",\",\n \"for the discretization. topk : Keeps the topk most frequent categories and merge\",\n \"by[0] ) result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for\",\n \"if it is part of the DB version you are using. Returns -------\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ----------\",\n \"str, optional Numerical vColumn to use when the parameter method is set to\",\n \"\\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\":\",\n \"0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE\",\n \"elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \": Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize : Discretizes the\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])])\",\n \"in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\",\",\n \"return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---#\",\n \"val): self.__dict__[attr] = val # # Methods # # ---# def aad(self): \\\"\\\"\\\"\",\n \"---------- argv: object Any amount of expressions. The expression generated will look like:\",\n \"of the 'topk' method. new_category: str, optional The name of the merging category\",\n \"their distributions as percents. Parameters ---------- k: int, optional Number of most occurent\",\n \"consider when drawing the box plot. The other categories will be filtered. ax:\",\n \"advantage Vertica’s # speed and built-in analytics and machine learning features. It supports\",\n \"2\\\". copy_name: str, optional If not empty, a copy will be created using\",\n \"vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \"vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the\",\n \"vColumn. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str):\",\n \"max_floor = 0 all_partition = by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]:\",\n \"None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( cmax,\",\n \"the parameter method is set to 'cat_stats'. Returns ------- tablesample An object containing\",\n \": Creates a new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the\",\n \"the entire relation, a vColumn can be seen as one column of that\",\n \"self.parent[y].nunique() == 2, TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) )\",\n \"* i + 1] ... END odd : CASE ... WHEN vColumn =\",\n \"(\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int,\",\n \"by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\"\",\n \") if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE\",\n \"verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h,\",\n \"Parameters ---------- by: str, optional vColumn to use to partition the data. bandwidth:\",\n \"start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step))\",\n \"self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) #\",\n \"if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias,\",\n \"to the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"Returns the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])])\",\n \"right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \") ) query += [lp + tmp_query + rp] query = \\\"WITH vdf_table\",\n \"chart. donut : Donut chart. rose : Rose chart. It can also be\",\n \"to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{}\",\n \"prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also\",\n \"power of another number round : rounds a value to a specified number\",\n \"vColumn type is date like). The vColumn will be transformed. Parameters ---------- field:\",\n \"str, optional The vColumn to use to compute the aggregation. max_cardinality: int, optional\",\n \"] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using a\",\n \"new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent,\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic\",\n \"have a numerical value\\\" ) lower_when = ( \\\"WHEN {} < {} THEN\",\n \"2, ParameterError( \\\"Parameter 'nbins' must be greater or equals to 2 in case\",\n \"1 then this method will return the mode of the vColumn. Returns -------\",\n \"input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\",\",\n \"optimal h. auto : Combination of Freedman Diaconis and Sturges. freedman_diaconis : Freedman\",\n \"item in result], } return tablesample(values) # ---# def value_counts(self, k: int =\",\n \"else \\\"\\\" query, cat = [], self.distinct() if len(cat) == 1: lp, rp\",\n \"except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from\",\n \"\\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), )\",\n \"func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the\",\n \"response partitioned by the different vColumn categories. Parameters ---------- response: str Response vColumn.\",\n \"COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_\",\n \"Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies :\",\n \"Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice : Slices\",\n \"h will be computed if the parameter is empty or invalid. max_cardinality: int/tuple,\",\n \"input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions\",\n \"by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])])\",\n \"a maximum depth of 10. response: str, optional Response vColumn when method is\",\n \") model.drop() return result except: model.drop() raise # ---# def describe( self, method:\",\n \"result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT\",\n \"* (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total) conj\",\n \"expr = \\\", \\\".join(expr) + \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True,\",\n \"func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype =\",\n \"float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters ----------\",\n \"/ # / / # \\\\ / # \\\\ / # \\\\/ #\",\n \"[int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) #\",\n \"boolean, False otherwise. Returns ------- bool True if the vColumn is boolean. See\",\n \"vColumns. bfill : Back Propagation of the next element (Constant Interpolation). ffill :\",\n \"null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response partitioned by\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] #\",\n \"check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if\",\n \"optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = result sturges =\",\n \"work if it is part of the DB version you are using. Returns\",\n \"using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes the\",\n \"records. vDataFrame[].str_count : Computes the number of matches for the regular expression in\",\n \"or computed) nbins: int, optional Number of bins. If empty, an optimized number\",\n \"in (1, None), ValueError( \\\"vColumn doesn't allow slicing having steps different than 1.\\\"\",\n \"isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns\",\n \"booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if n == 0:\",\n \"import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model =\",\n \"str = \\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans: bool\",\n \"Returns ------- float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \": Sets the method to 'numerical' if the vColumn is numerical , 'categorical'\",\n \"for column in all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"',\",\n \") ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem\",\n \"med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not normalize {}\",\n \"= self.ctype() tail.name = self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"self.count() if (method == \\\"mode\\\") and (val == None): val = self.mode(dropna=True) if\",\n \"absolute value acos : trigonometric inverse cosine asin : trigonometric inverse sine atan\",\n \"] else: warning_message = \\\"Can not normalize {} using a Robust Z-Score -\",\n \"if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20,\",\n \"of expressions. The expression generated will look like: even: CASE ... WHEN vColumn\",\n \"(isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val =\",\n \"\\\"s were \\\" if total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]:\",\n \"optional Parent of the vColumn. One vDataFrame can have multiple children vColumns whereas\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn. The\",\n \"---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the\",\n \"max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations +=\",\n \"\\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) # ---# def str_slice(self, start: int, step: int):\",\n \"= 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%',\",\n \"converted to {}.\\\".format( self.alias, dtype ) ) return self.parent except Exception as e:\",\n \"def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise.\",\n \"the vColumn record by an input value. The vColumn will be transformed. Parameters\",\n \"to return. Returns ------- tablesample An object containing the result. For more information,\",\n \"for i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain)\",\n \"are the median and two input quantiles. Parameters ---------- ts: str TS (Time\",\n \"elements. same_width : Computes regular width bins. smart : Uses the Random Forest\",\n \"= ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\")\",\n \"sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\":\",\n \"to compute the Equal Frequency discretization\\\" ) total, query, nth_elems = nb, [],\",\n \"vColumn to use when the parameter method is set to 'cat_stats'. Returns -------\",\n \"in the partition. order_by: list, optional List of the vColumns to use to\",\n \"category. In this case, the parameter 'numcol' must be defined. numerical : Uses\",\n \"memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage.\",\n \"] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) /\",\n \"method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"]\",\n \"\\\"zscore\\\", by: list = [], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes\",\n \"== \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8,\",\n \"\\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent # ---#\",\n \"following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self): \\\"\\\"\\\"\",\n \"Cardinality threshold to use to determine if the vColumn will be considered as\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response,\",\n \"example, it can be 'minute' 'hour'... start: bool, optional If set to True,\",\n \") # ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of\",\n \"def hist( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int\",\n \"the method will return the transformation used instead of the parent vDataFrame. This\",\n \"------- bool True if the vColumn category is date. See Also -------- vDataFrame[].isbool\",\n \"+= [elem for elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) >\",\n \".values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6],\",\n \": Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of\",\n \"normalize( self, method: str = \\\"zscore\\\", by: list = [], return_trans: bool =\",\n \"max_cardinality: int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"prod : product range : difference between the max and the min sem\",\n \"= ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result = [distinct_count]\",\n \"not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\")\",\n \"= True if len(args) > 0: column = args[0] elif \\\"column\\\" in kwargs:\",\n \"return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if\",\n \"able to solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n):\",\n \"{}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in\",\n \") result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({},\",\n \"the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] =\",\n \"AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1) x\",\n \"\\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{}\",\n \"\\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \") result = [elem[0] for elem in result] elif self.isnum() and method in\",\n \"vColumn( name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0,\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"\\\"Parameter 'k' must be greater or equals to 2 in case of discretization\",\n \"(\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column)\",\n \"or equal to 1\\\") where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias)\",\n \"bool = False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most\",\n \"def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element.\",\n \"\\\"[Apply]: The vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"',\",\n \"self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__(\",\n \"100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem in sauv: if \\\"top\\\" in\",\n \"method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\",\",\n \"\\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\",\",\n \"memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory\",\n \"\\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\": {}, \\\"regr_sxx\\\":\",\n \"ParameterError( \\\"Length of parameter breaks must be equal to the length of parameter\",\n \"not (h) or h <= 0: if nbins <= 0: h = self.numh()\",\n \"the vColumn. The function variable must be composed of two flower brackets {}.\",\n \") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self,\",\n \"of seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent See\",\n \"{\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str):\",\n \"self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item\",\n \"result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN\",\n \"int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ----------\",\n \"[list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns =\",\n \"optional The name of the merging category when using the 'topk' method. RFmodel_params:\",\n \"= -1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h > 1) or\",\n \"Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method,\",\n \"column = [], self.alias for idx in range(len(breaks) - 1): first_elem, second_elem =\",\n \"OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query,\",\n \"{} {} missing value{} filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]:\",\n \"vColumn {} was converted to {}.\\\".format( self.alias, dtype ) ) return self.parent except\",\n \"check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns = [ column for column\",\n \"the vColumn is null, 1 otherwise. expr: str, optional SQL expression. by: list,\",\n \"self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str = \\\"density\\\",\",\n \"global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\",\",\n \")[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {} AS ord, {}::int AS\",\n \"\\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max,\",\n \"\\\"vColumn doesn't allow slicing having steps different than 1.\\\" ) index_stop = index.stop\",\n \"self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if\",\n \"empty.\\\" ) conditions, column = [], self.alias for idx in range(len(breaks) - 1):\",\n \"[ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format(\",\n \"from the vColumn. Parameters ---------- x: float If the vColumn type is date\",\n \") assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \\\"Length of\",\n \"Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM\",\n \"of the vColumn. The vColumn will be transformed. Parameters ---------- pat: str regular\",\n \"WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT\",\n \"lesser than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame\",\n \"(ex: 50% for the median) prod : product range : difference between the\",\n \"( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\",\",\n \"if isinstance(method, str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]),\",\n \"(isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN {} > {}\",\n \"float]), (\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {},\",\n \"stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({})\",\n \"input element to the vColumn. Parameters ---------- x: float If the vColumn type\",\n \"\\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\",\",\n \"self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The\",\n \"= ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"):\",\n \"---------- alias, str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations.\",\n \"BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query\",\n \"nth_elems += [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\",\",\n \"expected store usage (unit: b). Returns ------- int vColumn expected store usage. See\",\n \"used to compute the best splits when 'method' is set to 'smart'. A\",\n \"input vColumns using the input method. Parameters ---------- method: str, optional Method to\",\n \"new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL,\",\n \"mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if\",\n \"solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name =\",\n \"vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies a function\",\n \"range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg =\",\n \"-------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes\",\n \"FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive\",\n \"mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if\",\n \"will memorize the already computed aggregations to gain in performance. The catalog will\",\n \"purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame\",\n \"some specific records are in the vColumn and it returns the new vDataFrame\",\n \"'smart'.\\\" ) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import (\",\n \"for the discretization (must be > 1) Returns ------- tablesample An object containing\",\n \"\\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # #\",\n \"if the vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical\",\n \"BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC\",\n \"Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # You may not\",\n \"be transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str, optional\",\n \"{}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha,\",\n \"If empty, an optimized number of nbins will be computed. h: float, optional\",\n \"being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest\",\n \"OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in\",\n \"each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace,\",\n \"AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query,\",\n \"self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def\",\n \"mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not normalize {} using\",\n \"variance Other aggregations could work if it is part of the DB version\",\n \"changing the parameter 'name', you'll be able to solve this issue.\\\" ) new_vColumn\",\n \"only the input number of digits after the comma. Parameters ---------- n: int\",\n \"of: str, optional The vColumn to use to compute the aggregation. max_cardinality: int,\",\n \"\\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT NULL LIMIT 0\\\".format(\",\n \"= self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL(\",\n \"November 1993 the 3rd. area: bool, optional If set to True, draw an\",\n \"or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also\",\n \"copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ]\",\n \"\\\"mode\\\") and (val == None): val = self.mode(dropna=True) if val == None: warning_message\",\n \"the k most occurent elements and their distributions as percents. Parameters ---------- k:\",\n \"# __ __ ______ ______ __ __ __ __ __ __ __ #\",\n \"\\\"backfill\\\"]: all_partition += [elem for elem in order_by] for elem in all_partition: if\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str =\",\n \"return int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---# def\",\n \"self.alias, ) else: query = \\\"SELECT {} FROM (SELECT {} AS {}, {}\",\n \"comma. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function\",\n \"date like). The vColumn will be transformed. Parameters ---------- field: str The field\",\n \"1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, )\",\n \"Propagation of the first element (Constant Interpolation). mean : Average. median : median.\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule.\",\n \"threshold to use to determine if the vColumn will be considered as categorical.\",\n \"Number of elements to display. Returns ------- tablesample An object containing the result.\",\n \"[str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] +\",\n \"total > 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total\",\n \"self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold *\",\n \") else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans = (\\\"{}\",\n \": trigonometric inverse tangent cbrt : cube root ceil : value up to\",\n \"+ result + [self.max()] elif method == \\\"topk\\\": assert k >= 2, ParameterError(\",\n \"the vColumn using a bijection from the different categories to [0, n -\",\n \"(c) Copyright [2018-2022] Micro Focus or one of its affiliates. # Licensed under\",\n \"Forest with 20 trees and a maximum depth of 10. response: str, optional\",\n \"): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if\",\n \"the vColumn is boolean, False otherwise. Returns ------- bool True if the vColumn\",\n \"the computation. Returns ------- tablesample An object containing the result. For more information,\",\n \"str = \\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int\",\n \"is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method ==\",\n \"include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut\",\n \"Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar Chart of\",\n \"0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] =\",\n \"the vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate :\",\n \"like (date, datetime ...), the parameter 'x' will represent the number of seconds,\",\n \"other types to varchar. same_freq : Computes bins with the same number of\",\n \"FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_\",\n \"{} using a Robust Z-Score - The MAD is null !\\\".format( self.alias )\",\n \"risk dtype : vColumn type iqr : interquartile range kurtosis : kurtosis jb\",\n \"if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError(\",\n \"( ((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\")) or not (is_numeric)\",\n \"the quantile. For example: 0.25 represents Q1. approx: bool, optional If set to\",\n \"executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias,\",\n \"if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in\",\n \"vColumn. The category will be one of the following: date / int /\",\n \"+= [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"query = \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table\",\n \"threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns\",\n \"{} WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ),\",\n \"in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int = 10):\",\n \"using the MIN and the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"the vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---#\",\n \"{})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the\",\n \"end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"vColumns simplify several processes with its abstractions. Parameters ---------- alias: str vColumn alias.\",\n \"or (numcol), ParameterError( \\\"The parameter 'numcol' must be a vDataFrame column if the\",\n \"the vColumn using the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as\",\n \"|| ';' || (FLOOR({} / {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\",\",\n \"\\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column)\",\n \"in each record of the vColumn. The vColumn will be transformed. Parameters ----------\",\n \"response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {} must be binary to\",\n \"upper bound itself. Parameters ---------- lower: float, optional Lower bound. upper: float, optional\",\n \"median) prod : product range : difference between the max and the min\",\n \"transformation instead of the vDataFrame parent and do not apply it. This parameter\",\n \"model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING\",\n \"isinstance(by, str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\",\",\n \"0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1,\",\n \"# ---# def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"\\\"mean\\\", \\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\",\",\n \"self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the\",\n \"approx: bool, optional If set to True, the approximate cardinality is returned. By\",\n \"if distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM\",\n \"Union # VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox import\",\n \") # ---# def plot( self, ts: str, by: str = \\\"\\\", start_date:\",\n \"data around for processing, VerticaPy brings the logic to the data. # #\",\n \"Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str):\",\n \"{} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"optional The vColumn to use to compute the aggregation. max_cardinality: int, optional Maximum\",\n \"str = \\\"zscore\\\", by: list = [], return_trans: bool = False ): \\\"\\\"\\\"\",\n \"== 1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {}, AVG({}),\",\n \"aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters\",\n \": Replaces the regular expression matches in each of the vColumn records by\",\n \"= {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density(\",\n \"len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin,\",\n \"RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\": 20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters\",\n \"(avg and std). (x - avg) / std robust_zscore : Normalization using the\",\n \"max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd =\",\n \"round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input\",\n \"gaussian : Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman\",\n \"argv[2 * i] THEN argv[2 * i + 1] ... END odd :\",\n \"vDataFrame. Parameters ---------- name: str Name of the copy. Returns ------- vDataFrame self.parent\",\n \"elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"\\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if\",\n \"nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {}\",\n \"be used as categorical (No h will be picked or computed) nbins: int,\",\n \"------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"== \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"]\",\n \"occurent element density unique : cardinality (count distinct) var : variance Other aggregations\",\n \"1 and 2 to be used as categorical (No h will be picked\",\n \"by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if of:\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std #\",\n \"of the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]),\",\n \"AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias,\",\n \"\\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM\",\n \"at the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode :\",\n \"\\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert nbins\",\n \"expression is in each of the vColumn records. The vColumn will be transformed.\",\n \"hyperbolic sine sqrt : arithmetic square root tan : trigonometric tangent tanh :\",\n \"date / int / float / text / binary / spatial / uuid\",\n \"total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum).\",\n \"of the vColumn 'of'. max : Maximum of the vColumn 'of'. sum :\",\n \"a vColumn means simply not selecting it in the final generated SQL code.\",\n \"USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"\\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\ \\\\ \\\\____ \\\\ \\\\\",\n \"skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See\",\n \"using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate : Computes\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---# def tail(self, limit:\",\n \"in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, )\",\n \"Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the\",\n \"{}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\"\",\n \"in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice):\",\n \"float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---#\",\n \"bins used for the discretization (must be > 1) k: int, optional The\",\n \"+= [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was\",\n \"= \\\"\\\", max_cardinality: int = 6, nbins: int = 0, h: float =\",\n \"(response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] +=\",\n \"---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding.\",\n \"self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to {}.\\\".format( self.alias, dtype ) )\",\n \"topk most frequent categories and merge the other into one unique category. h:\",\n \"self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self,\",\n \"when first preparing your data. Parameters ---------- new_name: str The new vColumn alias.\",\n \") for i in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2]\",\n \"def quantile(self, x: float, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha,\",\n \"NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str = \\\"winsorize\\\",\",\n \"with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to\",\n \"of the vColumn records. The vColumn will be transformed. Parameters ---------- pat: str\",\n \"self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ),\",\n \"not be empty in case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response)\",\n \") # ---# def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold:\",\n \"vDataFrame[].str_count : Computes the number of matches for the regular expression in each\",\n \"# # Modules # # Standard Python Modules import math, re, decimal, warnings,\",\n \"|| ']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\",\",\n \"<= 0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit =\",\n \": Adds a new vColumn to the vDataFrame by using an advanced analytical\",\n \"conj = \\\"s were \\\" if len(all_new_features) > 1 else \\\" was \\\"\",\n \"0: nullifzero = 0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin\",\n \"new feature by evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode :\",\n \"to convert to use to convert the vColumn. If this parameter is equal\",\n \"a numerical column for each vColumn category. In this case, the parameter 'numcol'\",\n \"p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame\",\n \"\\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column\",\n \"/ {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin,\",\n \"time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv):\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the histogram\",\n \"from verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds)\",\n \"x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts the\",\n \"0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn\",\n \"plot of the vColumn. The aggregations used are the median and two input\",\n \"def bar( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int\",\n \"\\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 *\",\n \") query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1 - {}) AS non_events,\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool,\",\n \"type date like. Optimized h will be computed if the parameter is empty\",\n \"the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum See Also\",\n \"= 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of the\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest\",\n \"str): by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by,\",\n \"pre-computed aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str : List\",\n \"Uses numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent\",\n \"pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"self.alias, len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode =\",\n \": most occurent element percent : percent of non-missing elements q% : q\",\n \"\\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({} -\",\n \"* result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query =\",\n \"n: int, optional Integer corresponding to the offset. For example, if n =\",\n \"to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self,\",\n \"'\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name =\",\n \"MinMax (min and max). (x - min) / (max - min) by: list,\",\n \"= \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {} FROM\",\n \"also be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The\",\n \"( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was\",\n \"val = {self.alias: val} return self.parent.isin(val) # ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"- n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"',\",\n \"prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct()\",\n \"largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature\",\n \"BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format(\",\n \"\\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_\",\n \"\\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]),\",\n \"data stored in Vertica, taking advantage Vertica’s # speed and built-in analytics and\",\n \"method on the vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing\",\n \"vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\",\",\n \"evaluating some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn\",\n \"max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h),\",\n \"self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__(\",\n \"/ date, optional Input End Date. For example, time = '03-11-1993' will filter\",\n \"of the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if\",\n \"to use to sort the data when using TS methods. Returns ------- vDataFrame\",\n \"-= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations +=\",\n \") return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct\",\n \"), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False,\",\n \"AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or\",\n \"-1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements\",\n \"response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the response\",\n \"to 1\\\") where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna)\",\n \"self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val):\",\n \"\\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average See Also\",\n \"data. Parameters ---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent\",\n \"return tablesample(values) # ---# def value_counts(self, k: int = 30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing\",\n \"\\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY\",\n \"\\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans] sauv = {}\",\n \"total = abs(self.count() - total) except Exception as e: self.transformations = [elem for\",\n \"is very useful for testing to be able to look at the final\",\n \"slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent See Also\",\n \"the vColumns to use to sort the data when using TS methods. Returns\",\n \"self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations to compute\",\n \"fill the vColumn outliers. mean : Replaces the upper and lower outliers by\",\n \"\\\"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL GROUP BY\",\n \"elif self.isnum(): if method == \\\"zscore\\\": if n == 0: nullifzero = 0\",\n \"datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)\",\n \"the NULL value. winsorize : Clips the vColumn using as lower bound quantile(alpha)\",\n \"kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D(\",\n \"conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode = get_dummies #\",\n \"The axes to plot on. **style_kwds Any optional parameter to pass to the\",\n \"and method in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0: if\",\n \"rose : Rose chart. It can also be a cutomized aggregation (ex: AVG(column1)\",\n \"\\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of\",\n \"by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad,\",\n \"vColumn {} was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self,\",\n \"\\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__()\",\n \"schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema, name=\\\"view\\\") tmp_model_name = gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins\",\n \"draw the Plot. start_date: str / date, optional Input Start Date. For example,\",\n \"self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by\",\n \"range plot of the vColumn. The aggregations used are the median and two\",\n \"sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for\",\n \"or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to be\",\n \"ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the\",\n \"(\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), (\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0]\",\n \"\\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else 0 for\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based\",\n \"the specified name. \\\\u26A0 Warning : SQL code generation will be slower if\",\n \"using. Returns ------- tablesample An object containing the result. For more information, see\",\n \"FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha =\",\n \"column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines\",\n \"--------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list Distinct caterogies\",\n \"# \\\\ / _ __|_. _ _ |_) # \\\\/ (/_| | |(_(_||\",\n \"to use to order the data. The vColumn type must be date like\",\n \"else result[0][0] if not (dropna): n = \\\"\\\" if (n == 1) else\",\n \"from matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin = self.min()\",\n \"a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self,\",\n \"self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {}, MIN(ord) AS ord, SUM(1\",\n \"count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0], result[3], result[4], result[6], result[7], )\",\n \"{}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"]\",\n \"else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\":\",\n \"return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) )\",\n \"elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method ==\",\n \"if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method\",\n \"return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and method == \\\"smart\\\":\",\n \"number of vColumn distinct elements to be used as categorical. The less frequent\",\n \"\\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower() if self.isnum() and\",\n \"Draws the Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to\",\n \"check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]),\",\n \": difference between the max and the min sem : standard error of\",\n \"!\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n == 1) and (self.parent[by[0]].nunique()\",\n \"MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n ==\",\n \"--------------------------------------------------------------------------- Computes the Information Value (IV) / Weight Of Evidence (WOE) Table. It\",\n \"use_threshold: bool = True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the\",\n \"the vColumn will be considered as categorical. numcol: str, optional Numerical vColumn to\",\n \"This parameter is very useful for testing to be able to look at\",\n \"the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\",\",\n \"to use this method when first preparing your data. Parameters ---------- new_name: str\",\n \"+= [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend(\",\n \"the slicing instead of the ceiling. Returns ------- vDataFrame self.parent See Also --------\",\n \"{}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL(\",\n \"ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias,\",\n \"((is_date) and not (method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\":\",\n \"/ float / text / binary / spatial / uuid / undefined Returns\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ---------- name:\",\n \"if (isinstance(upper, (float, int))) else \\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when,\",\n \": Average. median : median. mode : mode (most occurent element). 0ifnull :\",\n \"each record of the vColumn. The vColumn will be transformed. Parameters ---------- pat:\",\n \"vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\",\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation = [ ( \\\"({}\",\n \"(SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION\",\n \"the median) prod : product range : difference between the max and the\",\n \"default function to the vColumn. Parameters ---------- func: str Function to use to\",\n \"of the vColumn. Parameters ---------- by: str, optional vColumn to use to partition\",\n \"generated SQL code. Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if\",\n \"+= sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str =\",\n \"self.parent See Also -------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if\",\n \"by: str, optional vColumn to use to partition the TS. start_date: str /\",\n \"by using an advanced analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func,\",\n \"Number of most occurent elements to return. Returns ------- tablesample An object containing\",\n \"to 2 in case of discretization using the method 'smart'.\\\" ) assert response,\",\n \"if method == \\\"zscore\\\": if n == 0: nullifzero = 0 avg, stddev\",\n \"the vColumn is numerical or of type date like. Optimized h will be\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks: list,\",\n \"p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))])\",\n \"tablesample An object containing the result. For more information, see utilities.tablesample. See Also\",\n \"filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers in\",\n \"self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return \\\"({}\",\n \"in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by] for\",\n \"datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles used\",\n \"/ {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS min,\",\n \"= 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit:\",\n \"bool True if the vColumn category is date. See Also -------- vDataFrame[].isbool :\",\n \"\\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else:\",\n \"assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\" ) assert\",\n \"self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj, ) ) else:\",\n \"copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by\",\n \"index_start = 0 if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int):\",\n \"!= None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join(\",\n \"!= 0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else:\",\n \"result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise\",\n \"(/_| | |(_(_|| \\\\/ # / # VerticaPy is a Python library with\",\n \"List of the vColumns to use to sort the data when using TS\",\n \"also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object,\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the\",\n \"the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ]\",\n \"cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import\",\n \"of 10. response: str, optional Response vColumn when method is set to 'smart'.\",\n \"element from the vColumn. Parameters ---------- x: float If the vColumn type is\",\n \"occurent elements to return. Returns ------- tablesample An object containing the result. For\",\n \"query, ) query = \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER\",\n \"vColumn type is date like (date, datetime ...), the parameter 'x' will represent\",\n \"method == \\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\" for i\",\n \"if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return\",\n \"new vColumn to the vDataFrame by using an advanced analytical function on a\",\n \"elif isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if\",\n \"data. count : Number of elements. density : Percentage of the distribution. mean\",\n \"method 'same_width' for numerical vColumns, cast the other types to varchar. same_freq :\",\n \"(method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message =\",\n \"\\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] != None else\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {} named\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std See\",\n \"(\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__(\",\n \"isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype\",\n \"of digits after the comma. Parameters ---------- n: int Number of digits to\",\n \"of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method: str\",\n \"FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({}\",\n \"Adds a new vColumn to the vDataFrame by using an advanced analytical function\",\n \"datetime ...), the parameter 'x' will represent the number of seconds, otherwise it\",\n \"\\\"\\\"\\\" if isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])])\",\n \"---------- x: float A float between 0 and 1 that represents the quantile.\",\n \") title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) #\",\n \"str, optional The vColumn to use to compute the aggregation. h: int/float/tuple, optional\",\n \"( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION\",\n \"/ QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK\",\n \": Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice :\",\n \"({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile\",\n \"( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert\",\n \"transformations: list = [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations\",\n \"1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {}\",\n \"the above. The idea is simple: instead of moving # data around for\",\n \"0: warning_message = \\\"Can not normalize {} using a Z-Score - The Standard\",\n \"index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0:\",\n \"\\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION\",\n \"partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype\",\n \"n, [int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp\",\n \"right, [bool]), ] ) assert self.isnum() or self.isdate(), TypeError( \\\"cut only works on\",\n \"max : Maximum of the vColumn 'of'. sum : Sum of the vColumn\",\n \"**style_kwds) # ---# def category(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn.\",\n \"THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) +\",\n \"Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the vColumn\",\n \"\\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr)\",\n \"where = \\\" WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\"\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---#\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format(\",\n \"in each record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\",\",\n \"= catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in\",\n \"the Robust Z-Score (median and mad). (x - median) / (1.4826 * mad)\",\n \"/ / # |______ / / / # |____/ / / # _____________\",\n \"Normalization\\\") return self.parent # ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"elem[1] != None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"closed on the right. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\",\",\n \"\\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias\",\n \"1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", )\",\n \"n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result)\",\n \"Parameters ---------- pat: str regular expression. Returns ------- vDataFrame self.parent See Also --------\",\n \"== None): val = self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn\",\n \"\\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else:\",\n \"order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---#\",\n \"limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {} FROM\",\n \"if (nullifzero) else \\\"\\\", stddev ) else: final_transformation = [ ( \\\"({} -\",\n \"1 or not (labels), ParameterError( \\\"Length of parameter breaks must be equal to\",\n \"based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]),\",\n \": Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" if\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing\",\n \"or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\",\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset\",\n \"SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns\",\n \"if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(),\",\n \"__ __ __ __ __ __ # /\\\\ \\\\ / / /\\\\ ___\\\\\",\n \"return parent # ---# def drop_outliers( self, threshold: float = 4.0, use_threshold: bool\",\n \"ctype, category)] self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with\",\n \"transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) )\",\n \"END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"Method to use to compute the optimal h. auto : Combination of Freedman\",\n \"FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query,\",\n \"name the new categories. If empty, names will be generated. include_lowest: bool, optional\",\n \"lesser than the lower bound to the lower bound itself and the values\",\n \"to the vColumn. Parameters ---------- x: float If the vColumn type is date\",\n \"values = { \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for item\",\n \"= [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if\",\n \"depth of 10. response: str, optional Response vColumn when method is set to\",\n \"or self.isdate(), TypeError( \\\"cut only works on numerical / date-like vColumns.\\\" ) assert\",\n \"greater or equals to 2 in case of discretization using the method 'same_freq'\\\"\",\n \"to transform the vColumn. The function variable must be composed of two flower\",\n \"**kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list\",\n \"{}) * {} || ';' || (FLOOR({} / {}) * {} + {}{})\",\n \"Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns,\",\n \"max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1 and 2\",\n \"0: h = self.numh() else: h = (self.max() - self.min()) * 1.01 /\",\n \"to compute other vColumns. Parameters ---------- add_history: bool, optional If set to True,\",\n \"ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\")\",\n \"name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj\",\n \"expression. by: list, optional vColumns used in the partition. order_by: list, optional List\",\n \"add(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters\",\n \"END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations +=\",\n \"--------------------------------------------------------------------------- Python object which that stores all user transformations. If the vDataFrame represents\",\n \"= executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in\",\n \"int/float/str, optional Value to use to impute the vColumn. method: dict, optional Method\",\n \"of the vColumns to use to sort the data when using TS methods.\",\n \"set to True, the approximate quantile is returned. By setting this parameter to\",\n \"self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", )\",\n \"---# def boxplot( self, by: str = \\\"\\\", h: float = 0, max_cardinality:\",\n \"the Bar Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"\\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} <\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate():\",\n \"elem in catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index,\",\n \"compute the best splits when 'method' is set to 'smart'. A RF Regressor\",\n \"self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not normalize {} using\",\n \"independent variable in relation to the dependent variable. Parameters ---------- y: str Response\",\n \"k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\", \\\".join(expr) +\",\n \"expression matches in each of the vColumn records by an input value. \\\"\\\"\\\"\",\n \"int = 200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *=\",\n \"[ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\",\",\n \"\\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query = \\\"WITH\",\n \"\\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) )\",\n \"Also -------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies\",\n \"vColumn using 'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate :\",\n \"using a bijection from the different categories to [0, n - 1] (n\",\n \"END Returns ------- vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new\",\n \"(\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"] =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn record\",\n \"APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS\",\n \": Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with\",\n \"[ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response,\",\n \"self.parent See Also -------- vDataFrame.filter: Filters the data using the input expression. \\\"\\\"\\\"\",\n \"= ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) )\",\n \"False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\"\",\n \"head of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\"\",\n \"vColumn using 'var' (Variance). Returns ------- float var See Also -------- vDataFrame.aggregate :\",\n \"( result[0], result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table\",\n \"# ---# def tail(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail\",\n \"--------------------------------------------------------------------------- Draws the pie chart of the vColumn based on an aggregation. Parameters\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h,\",\n \"copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations +=\",\n \"\\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\"\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn based on\",\n \"mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\"\",\n \".replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\",\",\n \"absolute value function to the input vColumn. Returns ------- vDataFrame self.parent See Also\",\n \"of the vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex:\",\n \"table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias,\",\n \"method = method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp\",\n \"[list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert\",\n \"3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\",\",\n \"utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the\",\n \"20, \\\"max_depth\\\": 10} to train a Random Forest with 20 trees and a\",\n \"the Time Series of the vColumn. Parameters ---------- ts: str TS (Time Series)\",\n \"{ \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, } if\",\n \"FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(),\",\n \"= 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn\",\n \"name, parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\":\",\n \": Draws the Bar Chart of the input vColumns based on an aggregation.\",\n \"# \\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy is a Python\",\n \"is used to compute other vColumns. Parameters ---------- add_history: bool, optional If set\",\n \"return total # ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min'\",\n \"[int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k < 1) else\",\n \"'', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format(\",\n \"trigonometric inverse tangent cbrt : cube root ceil : value up to the\",\n \"verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY 1) x ORDER\",\n \"IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(),\",\n \"str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn\",\n \"auto : Sets the method to 'numerical' if the vColumn is numerical ,\",\n \"ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) # ---# def product(self):\",\n \"vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) #\",\n \"def memory_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn\",\n \"|| (FLOOR({} / {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h, h,\",\n \"+ by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if\",\n \"the response partitioned by the different vColumn categories. Parameters ---------- response: str Response\",\n \"sum : sum std : standard deviation topk : kth most occurent element\",\n \"AS {} FROM {} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype,\",\n \"method == \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ): n =\",\n \"len(result) trans = \\\"(CASE \\\" for i in range(1, n): trans += \\\"WHEN\",\n \"\\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold\",\n \"the vColumn with a user-specified rule. Parameters ---------- val: int/float/str, optional Value to\",\n \"END AS iv FROM ({}) x ORDER BY ord\\\".format( self.alias, query, ) title\",\n \"Maximum of the vColumn 'of'. sum : Sum of the vColumn 'of'. q%\",\n \"xlim: tuple, optional Set the x limits of the current axes. ax: Matplotlib\",\n \"* (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower()\",\n \"has already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to\",\n \"of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return\",\n \"aggregate # ---# def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"---# def bar( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype =\",\n \"drop_first else 0 for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix,\",\n \": Sum of the vColumn 'of'. q% : q Quantile of the vColumn\",\n \"the vColumn using the input list. Parameters ---------- breaks: list List of values\",\n \"'ts' is greater than November 1993 the 3rd. plot_median: bool, optional If set\",\n \"1], TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans\",\n \"decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str\",\n \"self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self, method: str\",\n \"greater than the threshold, it will be considered as an outlier. use_threshold: bool,\",\n \"isinstance(by, str): by = [by] if isinstance(order_by, str): order_by = [order_by] check_types( [\",\n \"self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted\",\n \"from verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not\",\n \"{} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method ==\",\n \"(\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or\",\n \"For example, time = '03-11-1993' will filter the data when 'ts' is lesser\",\n \"ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"else: h = (self.max() - self.min()) * 1.01 / nbins if h >\",\n \"of the vDataFrame parent and do not apply it. This parameter is very\",\n \"Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to\",\n \"the best splits when 'method' is set to 'smart'. A RF Regressor will\",\n \"input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS {}\",\n \"elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem] = None elif method\",\n \"str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations:\",\n \"The catalog will be updated when the parent vDataFrame is modified. Attributes ----------\",\n \"\\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\"\",\n \"transformation used instead of the parent vDataFrame. This parameter is used for testing\",\n \"License, Version 2.0 (the \\\"License\\\"); # You may not use this file except\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate :\",\n \"# / __ `\\\\ / / # | \\\\/ / / / #\",\n \"): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0}\",\n \"of elements to skip. Returns ------- tablesample An object containing the result. For\",\n \"same number of elements. same_width : Computes regular width bins. smart : Uses\",\n \"/\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\ \\\"-.\\\\\",\n \"verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model\",\n \"area, step, ax=ax, **style_kwds, ) # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"/ MINUTE / MONTH / QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR\",\n \"science life cycle, uses a ‘pipeline’ mechanism to sequentialize # data transformation operations,\",\n \"method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif\",\n \"[bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), (\",\n \"category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have multiple\",\n \"floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\")\",\n \": Propagation of the first element (Constant Interpolation). mean : Average. median :\",\n \"{}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---#\",\n \"BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\",\",\n \"# Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc import\",\n \"breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] )\",\n \"function's performance can drastically decrease. Returns ------- float quantile (or approximate quantile). See\",\n \"Series) vColumn to use to order the data. The vColumn type must be\",\n \"was normalized with the method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The\",\n \"), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {}\",\n \"tail of the vColumn. Parameters ---------- limit: int, optional Number of elements to\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix:\",\n \"(quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor =\",\n \"warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if n == 0: nullifzero\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"performance. The catalog will be updated when the parent vDataFrame is modified. Attributes\",\n \"---# def fillna( self, val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\",\",\n \"if the vColumn will be considered as categorical. numcol: str, optional Numerical vColumn\",\n \"bool = False, step: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1\",\n \"= self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax,\",\n \"optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method\",\n \"with the License. # You may obtain a copy of the License at\",\n \"in pure SQL used to transform the vColumn. The function variable must be\",\n \"response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn\",\n \"\\\"-.\\\\ \\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\\",\n \"self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1\",\n \"\\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] ) method = method.lower() if method == \\\"auto\\\": pre_comp =\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with\",\n \"+= [trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True,\",\n \"---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing\",\n \"statics of {} partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values\",\n \"the category of the vColumn. The category will be one of the following:\",\n \"0, Exception( \\\"Not enough values to compute the Equal Frequency discretization\\\" ) total,\",\n \"func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k\",\n \"gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot import\",\n \"elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", )\",\n \"self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of,\",\n \"/ SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR\",\n \"warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if n == 0: nullifzero\",\n \"was filled.\\\") self.transformations = [elem for elem in copy_trans] for elem in sauv:\",\n \"where, ) result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\",\",\n \"index < 0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET\",\n \"vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\",\",\n \"tuple] = (None, None), ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the spider plot\",\n \"See Also -------- vDataFrame[].str_count : Computes the number of matches for the regular\",\n \"law or agreed to in writing, software # distributed under the License is\",\n \"will also increase the time of the learning and scoring phases. xlim: tuple,\",\n \"float, optional Uses the Gaussian distribution to define the outliers. After normalizing the\",\n \"apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to\",\n \": Looks if some specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val,\",\n \"READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i\",\n \"It can also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib\",\n \"vColumns to use to sort the data when using TS methods. Returns -------\",\n \"= 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\\\".format(\",\n \"utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail\",\n \"float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns ------- int number\",\n \"import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def\",\n \"{}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\",\",\n \"raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif\",\n \"Methods # # ---# def __init__( self, alias: str, transformations: list = [],\",\n \"{} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i]\",\n \"values to compute the Equal Frequency discretization\\\" ) total, query, nth_elems = nb,\",\n \"in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0]\",\n \"== \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name =\",\n \"return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the\",\n \"if the vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") #\",\n \"vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.\",\n \"+ tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT * FROM {})\",\n \"largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An\",\n \"'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"unit: str, optional Slice size unit. For example, it can be 'minute' 'hour'...\",\n \"\\\"max\\\", ] if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\", \\\"dtype\\\"] +\",\n \"Slice size unit. For example, it can be 'minute' 'hour'... start: bool, optional\",\n \"elem in result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias),\",\n \"DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins -\",\n \"\\\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg FROM {} WHERE\",\n \"isinstance(func, str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try:\",\n \"check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]),\",\n \"BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {}\",\n \"mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv))\",\n \"1993 the 3rd. area: bool, optional If set to True, draw an Area\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def\",\n \"column to find the most relevant interval to use for the discretization. topk\",\n \"category. h: float, optional The interval size to convert to use to convert\",\n \"+= [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"or h <= 0: if nbins <= 0: h = self.numh() else: h\",\n \"2.0 (the \\\"License\\\"); # You may not use this file except in compliance\",\n \"of the following: CENTURY / DAY / DECADE / DOQ / DOW /\",\n \"return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'.\",\n \"input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See\",\n \"---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] =\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist :\",\n \"if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0]\",\n \"a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({},\",\n \"the mean skewness : skewness sum : sum std : standard deviation topk\",\n \"the head of the vColumn. Parameters ---------- limit: int, optional Number of elements\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import Line2D\",\n \"method used for the plot. gaussian : Gaussian kernel. logistic : Logistic kernel.\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type,\",\n \"\\\"AVG\\\" if by == []: if fun == \\\"AVG\\\": val = self.avg() elif\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if n == 1:\",\n \"be date like (date, datetime, timestamp...) or numerical. by: str, optional vColumn to\",\n \"same_freq : Computes bins with the same number of elements. same_width : Computes\",\n \"dropna, self.alias, topk, ) result = executeSQL( query, title=\\\"Computing the top{} categories of\",\n \"[ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method\",\n \"[int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] )\",\n \"cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"it returns the new vDataFrame of the search. Parameters ---------- val: list List\",\n \"1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing\",\n \"== None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply(\",\n \"NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype\",\n \"result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol\",\n \"warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method\",\n \"] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return\",\n \"method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater\",\n \"by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date,\",\n \"Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\"\",\n \"# ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error\",\n \"self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be\",\n \"# ---# def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is\",\n \"self.parent.__genSQL__(), self.alias, where, ) result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram\",\n \"self.isdate(), ParameterError( \\\"numh is only available on type numeric|date\\\" ) if self.isnum(): result\",\n \"train a Random Forest with 20 trees and a maximum depth of 10.\",\n \"percent : percent of non-missing elements q% : q quantile (ex: 50% for\",\n \"= 0 self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] =\",\n \"missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if isinstance(order_by, str): order_by\",\n \"was converted to {}.\\\".format( self.alias, dtype ) ) return self.parent except Exception as\",\n \"'of'. max : Maximum of the vColumn 'of'. sum : Sum of the\",\n \"the bar. If empty, an optimized h will be computed. ax: Matplotlib axes\",\n \"( \\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements\",\n \"vColumn using a time series rule. Parameters ---------- length: int Slice size. unit:\",\n \"used as categorical (No h will be picked or computed) ax: Matplotlib axes\",\n \"/ DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR /\",\n \"dtype), dtype, get_category_from_vertica_type(ctype=dtype), ) ] self.parent.__add_to_history__( \\\"[AsType]: The vColumn {} was converted to\",\n \"= [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e))\",\n \"Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]}\",\n \"0 ] # ---# def range_plot( self, ts: str, q: tuple = (0.25,\",\n \"-------- vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not\",\n \"input list. Parameters ---------- breaks: list List of values used to cut the\",\n \"else: final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\"\",\n \"type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips\",\n \"Parameters ---------- method: str, optional The method to use to discretize the vColumn.\",\n \"vColumn has already the alias {name}.\\\\nBy changing the parameter 'name', you'll be able\",\n \"self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"] = 1\",\n \"for elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem]\",\n \"element of the list will be included. right: bool, optional How the intervals\",\n \"Number representing the outliers threshold. Values lesser than quantile(alpha) or greater than quantile(1-alpha)\",\n \"query, ) query = \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events, CASE\",\n \"self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---# def\",\n \"for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers : Computes\",\n \"== \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE\",\n \"date like (date, datetime ...), the parameter 'x' will represent the number of\",\n \"inverse sine atan : trigonometric inverse tangent cbrt : cube root ceil :\",\n \"cardinality is returned. By setting this parameter to False, the function's performance can\",\n \"\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\",\",\n \"attr, val): self.__dict__[attr] = val # # Methods # # ---# def aad(self):\",\n \"\\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"== None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {}\",\n \"(\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in order_by]\",\n \"to impute the missing values. auto : Mean for the numerical and Mode\",\n \"\\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog)\",\n \"+ result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({})\",\n \"Also -------- vDataFrame[].str_count : Computes the number of matches for the regular expression\",\n \"self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation = [\",\n \"self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h #\",\n \"Exception( \\\"Not enough values to compute the Equal Frequency discretization\\\" ) total, query,\",\n \"using the input method. Parameters ---------- method: str, optional Method to use to\",\n \": Returns the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int,\",\n \"function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements). Returns ------- int\",\n \"(1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal\",\n \"will not be considered during the computation. Returns ------- tablesample An object containing\",\n \"of type date like. Optimized h will be computed if the parameter is\",\n \"is date. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return\",\n \"expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations\",\n \"---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the\",\n \"to the dependent variable. Parameters ---------- y: str Response vColumn. nbins: int, optional\",\n \"WHEN non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events /\",\n \"want to normalize by grouping by elements, please use a method in zscore|minmax\\\"\",\n \"import bar return bar(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---#\",\n \"with scikit-like functionality for conducting # data science projects on data stored in\",\n \"of elements to display. offset: int, optional Number of elements to skip. Returns\",\n \"method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\":\",\n \"use to impute the missing values. auto : Mean for the numerical and\",\n \"THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv\",\n \"The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method\",\n \"of the vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of\",\n \"\\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2,\",\n \"int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({}) THEN {}\",\n \"(\\\"response\\\", response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\",\",\n \"{ \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {},\",\n \"self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0]\",\n \") return parent # ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the\",\n \"str): method = method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha,\",\n \"of the response partitioned by the different vColumn categories. Parameters ---------- response: str\",\n \"have one parent. catalog: dict, optional Catalog where each key corresponds to an\",\n \"logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins:\",\n \"\\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s were \\\"\",\n \"is boolean. vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return\",\n \"median See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"the pie chart of the vColumn based on an aggregation. Parameters ---------- method:\",\n \"to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\",\",\n \"-------- vDataFrame[].str_count : Computes the number of matches for the regular expression in\",\n \"using a mean encoding with {} as Response Column.\\\".format( self.alias, response ) )\",\n \"h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans =\",\n \"\\\"NULL\\\", ) for elem in result if elem[2] != None ] ), )\",\n \"second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l, close_r =\",\n \"vColumn can be seen as one column of that relation. vColumns simplify several\",\n \"to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] +=\",\n \"(median absolute deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes\",\n \"self.transformations += final_transformation sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]\",\n \"0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events\",\n \"== \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(), self.ctype()\",\n \"in case of discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans\",\n \"int, optional Number of elements to display. Returns ------- tablesample An object containing\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy of\",\n \") for elem in result if elem[2] != None ] ), ) executeSQL(\",\n \"size. unit: str, optional Slice size unit. For example, it can be 'minute'\",\n \"if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column\",\n \"the distinct categories of the vColumn. Returns ------- list Distinct caterogies of the\",\n \"to the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also --------\",\n \"\\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\", step, [int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\",\",\n \"Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types(\",\n \": Uses only categorical aggregations during the computation. cat_stats : Computes statistics of\",\n \"= \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = (\",\n \"**kwargs) # ---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str =\",\n \"of non-missing elements cvar : conditional value at risk dtype : vColumn type\",\n \"y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] +=\",\n \"try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({})\",\n \"k: int = -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k\",\n \"input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority]\",\n \"this file except in compliance with the License. # You may obtain a\",\n \"vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding.\",\n \"(1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower()\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms the vColumn using a time\",\n \"elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges, fd)\",\n \"a specific TS field from the vColumn (only if the vColumn type is\",\n \"\\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and not\",\n \"jb : Jarque-Bera index mad : median absolute deviation max : maximum mean\",\n \"or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\")\",\n \"vColumn will be transformed. Parameters ---------- start: int Start of the slicing. step:\",\n \"greater than November 1993 the 3rd. area: bool, optional If set to True,\",\n \"numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\" # ---# def isin(self, val: list, *args):\",\n \"'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max\",\n \"float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"the Bar Chart of the input vColumns based on an aggregation. \\\"\\\"\\\" check_types(\",\n \"k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER\",\n \"bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\":\",\n \"GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias,\",\n \"+ result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\",\",\n \"**style_kwds ) model.drop() return result except: model.drop() raise # ---# def describe( self,\",\n \"= \\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({}\",\n \"cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1})\",\n \"\\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ # # # ---# class vColumn(str_sql): \\\"\\\"\\\"\",\n \"def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique'\",\n \"not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy changing the parameter\",\n \"when the vColumn is null, 1 otherwise. expr: str, optional SQL expression. by:\",\n \"verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut, rose, ax=None,\",\n \"\\\"issue.\\\" ) for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k)\",\n \"List of the different transformations. Each transformation must be similar to the following:\",\n \"vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes the\",\n \"AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" +\",\n \"hot encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj,\",\n \"Returns ------- float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"use to order the data. The vColumn type must be date like (date,\",\n \"each of the vColumn records. vDataFrame[].str_count : Computes the number of matches for\",\n \"the input element to the vColumn. Parameters ---------- x: float If the vColumn\",\n \"response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must\",\n \"= max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99)\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise. Returns -------\",\n \"elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in\",\n \"check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\",\",\n \"under the License. # # |_ |~) _ _| _ /~\\\\ _ |.\",\n \"elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\")\",\n \": trigonometric cotangent exp : exponential function floor : value down to the\",\n \"alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha)\",\n \"vColumn to use to partition the TS. start_date: str / date, optional Input\",\n \"\\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]),\",\n \"[ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr\",\n \"used to compute other vColumns. Parameters ---------- add_history: bool, optional If set to\",\n \"occurent element). 0ifnull : 0 when the vColumn is null, 1 otherwise. expr:\",\n \"doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if method == \\\"zscore\\\": if\",\n \"\\\"[Normalize]: The vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias, method )\",\n \"MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING\",\n \"import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, )\",\n \"= 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func:\",\n \"**style_kwds, ) # ---# def plot( self, ts: str, by: str = \\\"\\\",\",\n \"self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) #\",\n \"See Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by\",\n \"--------------------------------------------------------------------------- Fills the vColumns outliers using the input method. Parameters ---------- method: str,\",\n \"index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format(\",\n \"Number of nbins. If empty, an optimized number of nbins will be computed.\",\n \"will be trained if the response is numerical (except ints and bools), a\",\n \"WEEK / YEAR Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices\",\n \"dummies ({name}).\\\\n\\\" \\\"It can be the result of using previously the method on\",\n \"interval to use for the discretization. topk : Keeps the topk most frequent\",\n \"self.isnum() and method == \\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\"\",\n \"( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"): result\",\n \"return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"when drawing the box plot. The other categories will be filtered. ax: Matplotlib\",\n \"query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return\",\n \"field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit,\",\n \"self.transformations += [trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]\",\n \"\\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]),\",\n \"verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name\",\n \"False rose = True if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of)\",\n \"= \\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias, y) result =\",\n \"[distinct_count, self.count()] + [item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] +\",\n \"result if elem[1] != None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format(\",\n \"), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__(\",\n \"= f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\" conditions += [ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN\",\n \"-------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"= \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {})\",\n \"LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} smallest\",\n \"to solve this issue.\\\" ) new_vColumn = vColumn( name, parent=self.parent, transformations=[item for item\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] ) if\",\n \"Parameters ---------- method: str, optional The method to use to aggregate the data.\",\n \"# entire data science life cycle, uses a ‘pipeline’ mechanism to sequentialize #\",\n \"= { \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for item in\",\n \"func=\\\"(CASE WHEN {} < {} THEN {} WHEN {} > {} THEN {}\",\n \"expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers( self,\",\n \"if not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else:\",\n \"| \\\\/ / / / # |______ / / / # |____/ /\",\n \"using a user-defined encoding. Parameters ---------- argv: object Any amount of expressions. The\",\n \"a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self,\",\n \"= sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass\",\n \"be computed if the parameter is empty or invalid. max_cardinality: int, optional Maximum\",\n \"boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self):\",\n \"(\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) )\",\n \") if distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT 'Others', SUM(count)\",\n \"input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent\",\n \"then this method will return the mode of the vColumn. Returns ------- str/float/int\",\n \"'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.25) AS 'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"--------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ---------- x: float Input\",\n \"vColumn. Parameters ---------- by: str, optional vColumn to use to partition the data.\",\n \"kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds )\",\n \"Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ),\",\n \"THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" )\",\n \"to display. offset: int, optional Number of elements to skip. Returns ------- tablesample\",\n \") executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ),\",\n \"vDataFrame[].slice : Slices the vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}',\",\n \"Robust Z-Score (median and mad). (x - median) / (1.4826 * mad) minmax\",\n \"method == \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method 'robust_zscore' is\",\n \"title = \\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias, y) result\",\n \"\\\"heavier\\\" if it is used to compute other vColumns. Parameters ---------- add_history: bool,\",\n \"---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count\",\n \"\\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func: str, x: float\",\n \"with the specified name. \\\\u26A0 Warning : SQL code generation will be slower\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) # ---# def memory_usage(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Verifies if the regular expression is in each of the vColumn records. vDataFrame[].str_count\",\n \"float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\",\",\n \"max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str):\",\n \") query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {})\",\n \"Returns ------- bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool\",\n \"{}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ) else: final_transformation =\",\n \"required by applicable law or agreed to in writing, software # distributed under\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [\",\n \"empty, names will be generated. include_lowest: bool, optional If set to True, the\",\n \"element (Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method: str,\",\n \"def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current\",\n \"must be empty.\\\" ) conditions, column = [], self.alias for idx in range(len(breaks)\",\n \"elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem: self.catalog[elem] =\",\n \"return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'kurtosis'.\",\n \"partition the data. method: str, optional The method to use to aggregate the\",\n \"self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn is numerical , 'categorical' otherwise. categorical : Uses only categorical aggregations during\",\n \"IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1})\",\n \"\\\"WHEN {} < {} THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int)))\",\n \"\\\"rose\\\"]), ] ) donut = True if pie_type == \\\"donut\\\" else False rose\",\n \"\\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/ \\\\/_/ #\",\n \"optional Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills\",\n \"not (is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '',\",\n \"+ result[\\\"avg\\\"][0], ) else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {})\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements and their distributions as\",\n \") result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx,\",\n \"into one unique category. h: float, optional The interval size to convert to\",\n \"[2 * IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n))\",\n \"expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return\",\n \"__repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self,\",\n \"= [distinct_count, self.count()] + [item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"]\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding\",\n \"[bool]), ] ) method = method.lower() if self.isnum() and method == \\\"smart\\\": schema\",\n \"approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters\",\n \"# Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # You may\",\n \"to pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html\",\n \"nbins: int = -1, k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params:\",\n \"self.distinct() if distinct_elements not in ([0, 1], [1, 0]) or self.isbool(): all_new_features =\",\n \"+ total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] )\",\n \"by = self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum() and\",\n \"than 1.\\\" ) index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)):\",\n \"= kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema\",\n \"optimized number of nbins will be computed. h: float, optional Interval width of\",\n \"[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"{}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self,\",\n \"float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using the input\",\n \"\\\".join(query) ) title = \\\"Describes the statics of {} partitioned by {}.\\\".format( numcol,\",\n \"specific TS field from the vColumn (only if the vColumn type is date\",\n \"{} LIMIT 1\\\".format( avg, stddev, self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev =\",\n \"to 2.\\\" ) assert len(breaks) == len(labels) + 1 or not (labels), ParameterError(\",\n \"VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table\",\n \"------- float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes the\",\n \"of the vColumn {} named {} was added to the vDataFrame.\\\".format( self.alias, name\",\n \"Drops the first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool,\",\n \"Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label\",\n \"float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response:\",\n \"---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records\",\n \"self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date,\",\n \"str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ----------\",\n \"After normalizing the data (Z-Score), if the absolute value of the record is\",\n \"not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)):\",\n \"most frequent categories and merge the other into one unique category. h: float,\",\n \"== 1) else str(int(n)) if isinstance(top, decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)],\",\n \"Number of digits to keep after the comma. Returns ------- vDataFrame self.parent See\",\n \": trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse\",\n \"the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---# def __len__(self):\",\n \"> 1) Returns ------- tablesample An object containing the result. For more information,\",\n \"else: trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method ==\",\n \"the regular expression in each record of the vColumn. The vColumn will be\",\n \"of the mean skewness : skewness sum : sum std : standard deviation\",\n \"be a vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date\",\n \"'{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query += [lp + tmp_query + rp]\",\n \"to the offset. For example, if n = 1 then this method will\",\n \"Parameters ---------- lower: float, optional Lower bound. upper: float, optional Upper bound. Returns\",\n \"PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not empty, a copy\",\n \"percent of non-missing elements q% : q quantile (ex: 50% for the median)\",\n \"# ---# def __init__( self, alias: str, transformations: list = [], parent=None, catalog:\",\n \"different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] = ( \\\"NULL\\\"\",\n \"---------- method: str, optional The method to use to aggregate the data. count\",\n \"(sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] =\",\n \"aggregations. parent, vDataFrame : Parent of the vColumn. transformations, str : List of\",\n \"pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater or equal to\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot( self.parent,\",\n \"percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0],\",\n \"vDataFrame[].extract : Extracts the regular expression in each record of the vColumn. vDataFrame[].str_slice\",\n \"Encode]: The vColumn {} was transformed using a mean encoding with {} as\",\n \"func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations),\",\n \"-------- vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1)\",\n \"True if the vColumn is boolean. vDataFrame[].isdate : Returns True if the vColumn\",\n \"the vColumn based on an aggregation. Parameters ---------- method: str, optional The method\",\n \"BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads\",\n \"= '03-11-1993' will filter the data when 'ts' is greater than November 1993\",\n \"(\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements\",\n \"a copy with the specified name. \\\\u26A0 Warning : SQL code generation will\",\n \"def __init__( self, alias: str, transformations: list = [], parent=None, catalog: dict =\",\n \"the 'topk' method. new_category: str, optional The name of the merging category when\",\n \"= {}, response: str = \\\"\\\", return_enum_trans: bool = False, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"-------- vDataFrame[].hist : Draws the histogram of the vColumn based on an aggregation.\",\n \"categories to consider when drawing the box plot. The other categories will be\",\n \"IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing\",\n \"vColumn. method: dict, optional Method to use to impute the missing values. auto\",\n \"self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return\",\n \"list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn\",\n \"(k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT\",\n \"\\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ]\",\n \"picked or computed) nbins: int, optional Number of bins. If empty, an optimized\",\n \"--------------------------------------------------------------------------- Slices and transforms the vColumn using a time series rule. Parameters ----------\",\n \"= 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN\",\n \"nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result]\",\n \"See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in the vColumn.\",\n \"close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label = f\\\"{close_l}{first_elem};{second_elem}{close_r}\\\"\",\n \"self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name,\",\n \"func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr\",\n \"{0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*) DESC\",\n \"aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max\",\n \"k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if (use_numbers_as_suffix) else\",\n \"\\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr,\",\n \"input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0]\",\n \"transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\":\",\n \"input quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use to\",\n \"for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", )\",\n \"THEN {} ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method\",\n \"expression matches in each of the vColumn records by an input value. vDataFrame[].str_slice\",\n \"argv[2 * i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent\",\n \"sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd else: best_h = max(sturges,\",\n \"winsorize : Clips the vColumn using as lower bound quantile(alpha) and as upper\",\n \"A RF Regressor will be trained if the response is numerical (except ints\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float\",\n \"self, breaks: list, labels: list = [], include_lowest: bool = True, right: bool\",\n \"# |____/ / / # _____________ / / # \\\\ / / /\",\n \"100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total)\",\n \"), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format(\",\n \"optional Interval width of the bar. If empty, an optimized h will be\",\n \"(\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int,\",\n \"\\\"varchar\\\", \\\"text\\\", ) else: trans = (\\\"FLOOR({}) || ''\\\", \\\"varchar\\\", \\\"text\\\") else: trans\",\n \"h will be computed if the parameter is empty or invalid. max_cardinality: int,\",\n \"style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1,\",\n \"the values lesser than the lower bound to the lower bound itself and\",\n \"= False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding algorithm.\",\n \"unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if (start) else\",\n \"= self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return\",\n \"elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i])\",\n \"vDataFrame \\\"heavier\\\" if it is used to compute other vColumns. Parameters ---------- add_history:\",\n \"the other types to varchar. same_freq : Computes bins with the same number\",\n \"Method to use to impute the missing values. auto : Mean for the\",\n \"(\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of)\",\n \") elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the\",\n \"{}, MIN(ord) AS ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM\",\n \"enough values to compute the Equal Frequency discretization\\\" ) total, query, nth_elems =\",\n \": Replaces the upper and lower outliers by their respective average. null :\",\n \"index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return\",\n \"float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def mul(self,\",\n \"if some specific records are in the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or\",\n \"vColumns will memorize the already computed aggregations to gain in performance. The catalog\",\n \"Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if the absolute\",\n \"the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the other\",\n \"response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to\",\n \"= \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if\",\n \"ELSE NULL END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\":\",\n \"are using. Returns ------- tablesample An object containing the result. For more information,\",\n \"\\\" for i in range(1, n): trans += \\\"WHEN {} BETWEEN {} AND\",\n \": exponential function floor : value down to the next whole number ln\",\n \"enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias,\",\n \"import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by:\",\n \"\\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\",\",\n \"title = \\\"Describes the statics of {} partitioned by {}.\\\".format( numcol, self.alias )\",\n \"outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha = \\\"NULL\\\"\",\n \"vColumn using the average of the response partitioned by the different vColumn categories.\",\n \"THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\"))\",\n \"* FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT\",\n \"aggregations during the computation. cat_stats : Computes statistics of a numerical column for\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box Plot\",\n \") method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError( \\\"The parameter\",\n \"## # # __ __ ______ ______ __ __ __ __ __ __\",\n \"/ / / # |______ / / / # |____/ / / #\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp !=\",\n \"plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5, approx=approx) #\",\n \"n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias)\",\n \"[bool]), ] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({},\",\n \"nbins used for the discretization (must be > 1) Returns ------- tablesample An\",\n \"query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] )\",\n \"input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower\",\n \"'' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\", \\\"''\\\")) for elem in\",\n \"mean_encode(self, response: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using the average of the\",\n \"numerical to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations\",\n \"be computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum\",\n \"labels: list = [], include_lowest: bool = True, right: bool = True, ):\",\n \"considered as an outlier. use_threshold: bool, optional Uses the threshold instead of the\",\n \"End Date. For example, time = '03-11-1993' will filter the data when 'ts'\",\n \"of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\",\",\n \"\\\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing the optimized histogram\",\n \"and (val == None): val = self.mode(dropna=True) if val == None: warning_message =\",\n \"object See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based\",\n \"\\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values = { \\\"index\\\":\",\n \"vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert\",\n \"str, transformations: list = [], parent=None, catalog: dict = {} ): self.parent, self.alias,\",\n \"Jarque-Bera index mad : median absolute deviation max : maximum mean : average\",\n \"You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND,\",\n \"i in range(parameters[\\\"n_estimators\\\"]) ] query = \\\"SELECT split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM\",\n \"method = method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by)\",\n \"= val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif\",\n \"value function to the input vColumn. Returns ------- vDataFrame self.parent See Also --------\",\n \"[\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), ) executeSQL( \\\"SELECT {} FROM\",\n \"OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({})\",\n \"optional parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes\",\n \"# ---# def min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns\",\n \"check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def\",\n \"already computed aggregations to gain in performance. The catalog will be updated when\",\n \"vColumn will be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\",\",\n \"sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return total\",\n \"\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime,\",\n \"using the input method. Parameters ---------- method: str, optional The method to use\",\n \"{}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL GROUP BY\",\n \"/ NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query\",\n \"int vColumn cardinality (or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the\",\n \"by: str = \\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"{}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {},\",\n \"(\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"cat_priority\\\", cat_priority,\",\n \"self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func 'x ->\",\n \"[\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h\",\n \"(ex: 50% to get the median). It can also be a cutomized aggregation\",\n \"in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during the filling.\\\".format(e)) if total > 0:\",\n \"[int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} -\",\n \"= -1, k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict =\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize :\",\n \"the vColumn 'of'. sum : Sum of the vColumn 'of'. q% : q\",\n \"decrease. Returns ------- float/str median See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\",\",\n \"self.parent.__genSQL__() ), print_time_sql=False, ) except: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY\",\n \"http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing,\",\n \"TypeError( \\\"The column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool())\",\n \"in writing, software # distributed under the License is distributed on an \\\"AS\",\n \"cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\",\",\n \"self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the vColumn {} using the\",\n \"= \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] =\",\n \"[(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for\",\n \"median : median min : minimum mode : most occurent element percent :\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based\",\n \"elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations)\",\n \"else: query = \\\"SELECT {} FROM (SELECT {} AS {}, {} AS verticapy_agg\",\n \"is set to 'smart'. A RF Regressor will be trained if the response\",\n \"by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\",\",\n \"---------- method: str, optional The method to use to discretize the vColumn. auto\",\n \"val += list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) #\",\n \"import Union # VerticaPy Modules import verticapy from verticapy.utilities import * from verticapy.toolbox\",\n \"the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower()\",\n \"= kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar\",\n \"str, Function in pure SQL used to transform the vColumn. The function variable\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION\",\n \"warning_message = \\\"Can not normalize {} using a Robust Z-Score - The MAD\",\n \"+ rp] query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(),\",\n \"\\\\ / _ __|_. _ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/\",\n \"to True, draw a Step Plot. ax: Matplotlib axes object, optional The axes\",\n \"= max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99, ) fd\",\n \"of points to use to evaluate the approximate density function. Increasing this parameter\",\n \"most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"(only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val,\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def\",\n \"See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp\",\n \"elem in order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor =\",\n \"list = [], parent=None, catalog: dict = {} ): self.parent, self.alias, self.transformations =\",\n \"range kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute deviation\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]),\",\n \"Normalizes the input vColumns using the input method. Parameters ---------- method: str, optional\",\n \"vColumn has already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame\",\n \"with the same number of elements. same_width : Computes regular width bins. smart\",\n \"int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame\",\n \"available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr =\",\n \"the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be able to solve this\",\n \"stddev = std # ---# def store_usage(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn expected\",\n \"OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe,\",\n \"topk, ) result = executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k\",\n \"10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if\",\n \"root ceil : value up to the next whole number cos : trigonometric\",\n \"the tail of the vColumn. Parameters ---------- limit: int, optional Number of elements\",\n \"'order_by' must be a list of at least one element to use to\",\n \"Back Propagation of the next element (Constant Interpolation). ffill : Propagation of the\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna,\",\n \"Silverman kernel. nbins: int, optional Maximum number of points to use to evaluate\",\n \"record of the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]),\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min, max, median,\",\n \"e: self.transformations = [elem for elem in copy_trans] raise QueryError(\\\"{}\\\\nAn Error happened during\",\n \"bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the vColumn\",\n \"where the vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter:\",\n \"\\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"max_floor: max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations +=\",\n \"\\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format( e, self.alias, dtype )\",\n \"method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method is\",\n \"self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self):\",\n \"See Also -------- vDataFrame[].dropna : Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by,\",\n \"COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality +\",\n \"correlated features. use_numbers_as_suffix: bool, optional Uses numbers as suffix instead of the vColumns\",\n \"Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats\",\n \"';' || (FLOOR({} / {}) * {} + {}{}) || ']'\\\".format( \\\"{}\\\", h,\",\n \"matplotlib.lines import Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax\",\n \"to the input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame\",\n \"square root tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional\",\n \"not (\\\"cmap\\\" in kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if\",\n \"/ # \\\\/ / / # / / # / / # \\\\\",\n \") return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if self.category() == \\\"float\\\"\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean\",\n \"self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression is in\",\n \"func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\",\",\n \"vColumn by keeping only the input number of digits after the comma. Parameters\",\n \"DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].nsmallest : Returns the n smallest elements in\",\n \"= executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k if k >\",\n \"bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns\",\n \"from verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import * ##\",\n \"bool, optional How the intervals should be closed. If set to True, the\",\n \"check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k <\",\n \") result = executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k if\",\n \"verticapy.utilities import * from verticapy.toolbox import * from verticapy.errors import * ## #\",\n \"self.parent.shape()[0] if isinstance(index_stop, int): if index_stop < 0: index_stop += self.parent.shape()[0] limit =\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on an aggregation.\",\n \"vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL(\",\n \"\\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"will be computed. h: float, optional Interval width of the bar. If empty,\",\n \"(\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\",\",\n \"---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False\",\n \"{}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS\",\n \"float): category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype =\",\n \"k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {} AS {}, {} AS\",\n \"Parameters ---------- breaks: list List of values used to cut the vColumn. labels:\",\n \"self.parent[copy_name].catalog = self.catalog self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the func\",\n \"\\\" UNION ALL \\\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing\",\n \"self.parent, self.alias, self.transformations = ( parent, alias, [elem for elem in transformations], )\",\n \"= self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias)\",\n \"float, optional Interval width if the vColumn is numerical or of type date\",\n \"q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str):\",\n \"b). Returns ------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage :\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns\",\n \"category of the vColumn. The category will be one of the following: date\",\n \"\\\"The column 'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else\",\n \"method to use to discretize the vColumn. auto : Uses method 'same_width' for\",\n \"------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes\",\n \"method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"\\\"s were \\\" if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get\",\n \"def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import gen_colors from matplotlib.lines import\",\n \"return_trans, [bool]), ] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n\",\n \"of the different transformations. \\\"\\\"\\\" # # Special Methods # # ---# def\",\n \"like: even: CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 *\",\n \") if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent # ---#\",\n \"error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate : Computes\",\n \"express or implied. # See the License for the specific language governing permissions\",\n \"acos : trigonometric inverse cosine asin : trigonometric inverse sine atan : trigonometric\",\n \"+= [name] all_new_features += [name] conj = \\\"s were \\\" if len(all_new_features) >\",\n \"= 0 self.catalog[\\\"std\\\"] = 1 elif method == \\\"minmax\\\": self.catalog[\\\"min\\\"] = 0 self.catalog[\\\"max\\\"]\",\n \"can also be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes\",\n \"if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val += list(args)\",\n \"hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def\",\n \"median is returned. By setting this parameter to False, the function's performance can\",\n \"1): first_elem, second_elem = breaks[idx], breaks[idx + 1] if right: op1, op2, close_l,\",\n \"elements to be used as categorical. The less frequent elements will be gathered\",\n \"4) elif h > 0.000001: h = round(h, 6) if self.category() == \\\"int\\\":\",\n \"\\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the pie chart of the vColumn\",\n \"- avg) / std robust_zscore : Normalization using the Robust Z-Score (median and\",\n \"numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame self.parent See\",\n \"{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count()\",\n \"(\\\"nbins\\\", nbins, [float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from\",\n \"draw a Step Plot. ax: Matplotlib axes object, optional The axes to plot\",\n \"\\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"of: str = \\\"\\\", max_cardinality: int = 6, h: float = 0, pie_type:\",\n \"most occurent element density unique : cardinality (count distinct) var : variance Other\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ---------- func: list\",\n \"categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn\",\n \"ParameterError( \\\"Parameter 'k' must be greater or equals to 2 in case of\",\n \"+ \\\", {})\\\".format(len(distinct_elements)) self.transformations += [(expr, \\\"int\\\", \\\"int\\\")] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.catalog[\\\"count\\\"] = self.parent.shape()[0]\",\n \"- {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format(\",\n \"[ ( \\\"({} - {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if\",\n \"[elem[0] for elem in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"): if\",\n \"\\\"int\\\") # ---# def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {} WHERE\",\n \"topk(self, k: int = -1, dropna: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"---# def nsmallest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ----------\",\n \"str = \\\"\\\", method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int,\",\n \"float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx else \\\"\\\" return self.aggregate(func=[prefix\",\n \"() FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha\",\n \"a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a\",\n \"\\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ),\",\n \"See Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds\",\n \"# \\\\ / / / # \\\\_______/ / / # ______ / /\",\n \"(\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0: if nbins <= 0:\",\n \"Applies the absolute value function to the input vColumn. Returns ------- vDataFrame self.parent\",\n \"def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from the\",\n \"with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha,\",\n \"vColumn is numerical or of type date like. Optimized h will be computed\",\n \"Random Forest with 20 trees and a maximum depth of 10. response: str,\",\n \"vColumn to use to compute the aggregation. h: int/float/tuple, optional Interval width of\",\n \"= \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for\",\n \"for Normalization\\\") return self.parent # ---# def nsmallest(self, n: int = 10): \\\"\\\"\\\"\",\n \") for elem in self.catalog: total += sys.getsizeof(elem) return total # ---# def\",\n \"for elem in order_by] + by) by = self.parent.format_colnames(by) if method == \\\"auto\\\":\",\n \"{}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor): self.transformations\",\n \"a response column to find the most relevant interval to use for the\",\n \"copy will be created using the input Name. Returns ------- vDataFrame self.parent See\",\n \": standard error of the mean skewness : skewness sum : sum std\",\n \"(prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first\",\n \"vColumn records. vDataFrame[].extract : Extracts the regular expression in each record of the\",\n \"be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers : Drops outliers\",\n \"\\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol'\",\n \"= [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\", \\\"min\\\", \\\"approx_25%\\\",\",\n \"using an input 'quantile'. Parameters ---------- x: float A float between 0 and\",\n \"# ---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn.\",\n \"[float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None) or (upper !=\",\n \"# ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns -------\",\n \"the input vColumn based on an aggregation. Parameters ---------- by: str, optional vColumn\",\n \"= executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", )\",\n \"If empty, an optimized h will be computed. ax: Matplotlib axes object, optional\",\n \"\\\"robust_zscore\\\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ----------\",\n \"mad : median absolute deviation max : maximum mean : average median :\",\n \"min(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'min' (Minimum). Returns ------- float/str minimum\",\n \"[\\\"name\\\", \\\"dtype\\\"] + index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and\",\n \"datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool =\",\n \"mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---# def mad(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Extracts a specific TS field from the vColumn (only if the vColumn type\",\n \"to 'smart'. A RF Regressor will be trained if the response is numerical\",\n \"the Gaussian distribution to identify outliers. After normalizing the data (Z-Score), if the\",\n \"vColumn category. In this case, the parameter 'numcol' must be defined. numerical :\",\n \"vColumn to use to order the data. The vColumn type must be date\",\n \"The vColumn will be transformed. Parameters ---------- to_replace: str Regular expression to replace.\",\n \"ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER\",\n \"method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"]\",\n \"try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ):\",\n \"[], self.distinct() if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp,\",\n \") except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {}\",\n \"vColumn from the vDataFrame. Dropping a vColumn means simply not selecting it in\",\n \"vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The\",\n \"- sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem]\",\n \"\\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\",\",\n \"\\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*)\",\n \"FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias,\",\n \"functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws\",\n \"self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str = \\\"density\\\",\",\n \"title=title) result.values[\\\"index\\\"] += [\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"]\",\n \"n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns -------\",\n \"and offers beautiful graphical options. # # VerticaPy aims to do all of\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins,\",\n \"Attributes ---------- alias, str : vColumn alias. catalog, dict : Catalog of pre-computed\",\n \"self.parent See Also -------- vDataFrame[].str_count : Computes the number of matches for the\",\n \"by: list, optional vColumns used in the partition. order_by: list, optional List of\",\n \"of the vColumn records. vDataFrame[].extract : Extracts the regular expression in each record\",\n \"30): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the k most occurent elements, how often they occur,\",\n \"using the mean encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]:\",\n \"vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the input vColumns.\",\n \"ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any optional\",\n \"optional How the intervals should be closed. If set to True, the intervals\",\n \"expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr)\",\n \"result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"]\",\n \"regular expression is in each of the vColumn records. vDataFrame[].str_count : Computes the\",\n \"asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt : cube\",\n \"method = \\\"mean\\\" if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total =\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER (PARTITION\",\n \"input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---# def fill_outliers(\",\n \"if not (isinstance(index_start, int)): index_start = 0 if index_start < 0: index_start +=\",\n \"when method is set to 'smart'. return_enum_trans: bool, optional Returns the transformation instead\",\n \"in (\\\"same_width\\\", \\\"auto\\\"): if not (h) or h <= 0: if nbins <=\",\n \"\\\\/ # _ # \\\\ / _ __|_. _ _ |_) # \\\\/\",\n \"TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent # ---# def nsmallest(self,\",\n \"func ) ): max_floor = max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -=\",\n \": cardinality (count distinct) var : variance Other aggregations could work if it\",\n \"be trained if the response is numerical (except ints and bools), a RF\",\n \"* ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int = 10): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"add_history: bool, optional If set to True, the information will be stored in\",\n \"= \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations +\",\n \"DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by])\",\n \"List of values used to cut the vColumn. labels: list, optional Labels used\",\n \"pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY\",\n \"from the vDataFrame.\\\".format(self.alias) ) return parent # ---# def drop_outliers( self, threshold: float\",\n \"{} ORDER BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias,\",\n \"arguments (example, power or mod), 'x' represents the second argument. Returns ------- vDataFrame\",\n \"in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 *\",\n \"= ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The\",\n \"BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing\",\n \"the precision but will also increase the time of the learning and scoring\",\n \"vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\",\",\n \") title = \\\"Describes the statics of {} partitioned by {}.\\\".format( numcol, self.alias\",\n \"prefix_sep.replace('\\\"', \\\"_\\\") if not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n\",\n \"ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS NOT\",\n \"method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if method\",\n \"the input method. Parameters ---------- method: str, optional The method to use to\",\n \"must be defined. numerical : Uses popular numerical aggregations during the computation. max_cardinality:\",\n \"1) and (self.parent[by[0]].nunique() < 50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({})\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.iv_woe :\",\n \"the vDataFrame by using an advanced analytical function on a specific vColumn. \\\"\\\"\\\"\",\n \"by: str = \\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins:\",\n \"than quantile(alpha) or greater than quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent\",\n \"gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if\",\n \"Dummies]: One hot encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias,\",\n \"is only available on type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe(\",\n \"= \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if (dropna) else \\\"\\\" query =\",\n \"= 6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {}, response: str =\",\n \"the histogram of the vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\",\",\n \"Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float mad See\",\n \"len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must be greater or equal\",\n \"the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif\",\n \": 0 when the vColumn is null, 1 otherwise. expr: str, optional SQL\",\n \"approximate median is returned. By setting this parameter to False, the function's performance\",\n \"else: for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func,\",\n \"if index_start < 0: index_start += self.parent.shape()[0] if isinstance(index_stop, int): if index_stop <\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot : Draws the Box\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/ \\\\/_/ \\\\/_/\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"min\\\"]).values[self.alias][0] #\",\n \"True, the approximate median is returned. By setting this parameter to False, the\",\n \"( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else:\",\n \"self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] =\",\n \"< 50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP\",\n \"in each of the vColumn records. The vColumn will be transformed. Parameters ----------\",\n \": trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp :\",\n \"in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in\",\n \": median. mode : mode (most occurent element). 0ifnull : 0 when the\",\n \"self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top\",\n \"/ undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns\",\n \"range : difference between the max and the min sem : standard error\",\n \"the vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---# def aggregate(self, func:\",\n \"use_threshold: bool, optional Uses the threshold instead of the 'alpha' parameter. alpha: float,\",\n \"IS NULL\\\".format(self.alias) if (category in (\\\"None\\\", None)) else \\\" WHERE {} = '{}'\\\".format(\",\n \"if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\",\",\n \"elem[2] != None else \\\"NULL\\\", ) for elem in result if elem[2] !=\",\n \"index) # ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count()\",\n \"the dummies. drop_first: bool, optional Drops the first dummy to avoid the creation\",\n \"def pie( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int\",\n \"data when 'ts' is lesser than November 1993 the 3rd. end_date: str /\",\n \"x != 0, ValueError(\\\"Division by 0 is forbidden !\\\") return self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\",\",\n \"method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def\",\n \"({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join( [ \\\"'{}'\\\".format(str(elem).replace(\\\"'\\\",\",\n \"except in compliance with the License. # You may obtain a copy of\",\n \"to use to compute the aggregation. max_cardinality: int, optional Maximum number of the\",\n \"> 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return\",\n \"- The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif\",\n \": trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square root tan\",\n \"{})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun\",\n \"__ __ __ __ __ __ __ # /\\\\ \\\\ / / /\\\\\",\n \"sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0\",\n \") if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold *\",\n \"cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to use\",\n \"BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 ) result = executeSQL(\",\n \"number of elements. same_width : Computes regular width bins. smart : Uses the\",\n \"\\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query = [\",\n \"deviation max : maximum mean : average median : median min : minimum\",\n \"{}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics\",\n \"int, optional The integer k of the 'topk' method. new_category: str, optional The\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent # ---# def\",\n \"'approx_25%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 -\",\n \"{})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0 THEN 0\",\n \"if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in\",\n \"{}\\\".format( e, self.alias, dtype ) ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"-------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]),\",\n \"('prefix', 'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\" ) for k\",\n \"the histogram of the vColumn based on an aggregation. Parameters ---------- method: str,\",\n \"decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ----------\",\n \"+= [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"]\",\n \"xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0], color=updated_dict(param,\",\n \"func: list List of the different aggregation. aad : average absolute deviation approx_unique\",\n \"number of nbins will be computed. h: float, optional Interval width of the\",\n \"= offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias return tail # ---# def\",\n \"Slices the vColumn. The vColumn will be transformed. Parameters ---------- start: int Start\",\n \"elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {}) AS {}\",\n \"parameter 'labels' + 1 or parameter 'labels' must be empty.\\\" ) conditions, column\",\n \"/ EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS /\",\n \"axes object See Also -------- vDataFrame.bar : Draws the Bar Chart of the\",\n \"vDataFrame can have multiple children vColumns whereas one vColumn can only have one\",\n \"return top # ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn\",\n \"= self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn {} has no\",\n \"in performance. The catalog will be updated when the parent vDataFrame is modified.\",\n \"def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns -------\",\n \"in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ),\",\n \"str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the\",\n \"from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) #\",\n \"query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id = {}, format\",\n \"in executeSQL( query=query, title=\\\"Computing the average of the {}'s lower and upper outliers.\\\".format(\",\n \"0: warning_message = \\\"Can not normalize {} using the MIN and the MAX.\",\n \"h = round(h, 4) elif h > 0.000001: h = round(h, 6) if\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the\",\n \"will be considered as an outlier. use_threshold: bool, optional Uses the threshold instead\",\n \"statistics of a numerical column for each vColumn category. In this case, the\",\n \"Z-Score - The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"= sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) for elem\",\n \"pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events\",\n \") ) # ---# def avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg'\",\n \"= \\\"The vColumn {} has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters\",\n \"USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias,\",\n \"assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing having steps different\",\n \"(nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method !=\",\n \"vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk =\",\n \"gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] =\",\n \"will be slower if the vDataFrame has been transformed multiple times, so it's\",\n \"self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__(\",\n \"# ---# def __len__(self): return int(self.count()) # ---# def __nonzero__(self): return self.count() >\",\n \"computed. nbins: int, optional Number of bins used for the discretization (must be\",\n \"{} < {} THEN {} WHEN {} > {} THEN {} ELSE {}\",\n \"[ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ]\",\n \"VerticaPy is a Python library with scikit-like functionality for conducting # data science\",\n \"result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\",\",\n \"discretization (must be > 1) Returns ------- tablesample An object containing the result.\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.plot : Draws the time\",\n \"parameter to pass to the geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/\",\n \"(self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query =\",\n \"using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]),\",\n \"Area Plot. step: bool, optional If set to True, draw a Step Plot.\",\n \"memory usage. Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage\",\n \"---# def aggregate(self, func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"return self.parent # ---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float\",\n \"(date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles\",\n \"(\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha,\",\n \"category is date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn\",\n \"based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\",\",\n \"= self.parent.format_colnames(column) columns += [column] if not (\\\"cmap\\\" in kwargs): from verticapy.plot import\",\n \"model.drop() return result except: model.drop() raise # ---# def describe( self, method: str\",\n \") return self.parent # ---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"most occurent elements and their distributions as percents. Parameters ---------- k: int, optional\",\n \"True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the\",\n \"optional The type of pie chart. auto : Regular pie chart. donut :\",\n \"represents Q1. approx: bool, optional If set to True, the approximate quantile is\",\n \"( \\\"UNION ALL (SELECT 'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM\",\n \"must be equal to the length of parameter 'labels' + 1 or parameter\",\n \"COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std, MIN({3}{4}) AS\",\n \"to use to normalize. zscore : Normalization using the Z-Score (avg and std).\",\n \": Returns the vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if\",\n \"index): if isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow\",\n \"= method.lower() self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if\",\n \"'numcol' must be numerical\\\" ) cast = \\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query,\",\n \"with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) return\",\n \"optional vColumn to use to partition the data. h: float, optional Interval width\",\n \"vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val] val\",\n \"by an offset and a limit). Parameters ---------- limit: int, optional Number of\",\n \"deviation approx_unique : approximative cardinality count : number of non-missing elements cvar :\",\n \"def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the input vColumn.\",\n \"verticapy.plot import hist return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) #\",\n \"str, optional The describe method. auto : Sets the method to 'numerical' if\",\n \"percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3,\",\n \"---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the input\",\n \"self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if not\",\n \"= index.start if not (isinstance(index_start, int)): index_start = 0 if index_start < 0:\",\n \"the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\",\",\n \"is equal to 0, an optimised interval will be computed. nbins: int, optional\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also\",\n \"the search. See Also -------- vDataFrame.isin : Looks if some specific records are\",\n \"== \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\",\",\n \"ord\\\".format( self.alias, query, ) title = \\\"Computing WOE & IV of {} (response\",\n \"1993 the 3rd. end_date: str / date, optional Input End Date. For example,\",\n \"'of' (ex: 50% to get the median). It can also be a cutomized\",\n \"of = self.parent.format_colnames(of) from verticapy.plot import bar return bar(self, method, of, max_cardinality, nbins,\",\n \"a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h,\",\n \"kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema):\",\n \"with the method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn must\",\n \"\\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent,\",\n \"[str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ),\",\n \"partition the data. h: float, optional Interval width if the vColumn is numerical\",\n \"to partition the data. method: str, optional The method to use to aggregate\",\n \"see utilities.tablesample. See Also -------- vDataFrame[].tail : Returns the a part of the\",\n \"number of digits after the comma. Parameters ---------- n: int Number of digits\",\n \"None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\"\",\n \"/ DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK /\",\n \"self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object.\",\n \": Encodes the vColumn using the mean encoding of a response. \\\"\\\"\\\" import\",\n \"def describe( self, method: str = \\\"auto\\\", max_cardinality: int = 6, numcol: str\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by,\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters\",\n \"WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias )\",\n \"not normalize {} using the MIN and the MAX. MAX = MIN !\\\".format(\",\n \"See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"[self.alias] check = True if len(args) > 0: column = args[0] elif \\\"column\\\"\",\n \"--------------------------------------------------------------------------- Looks if some specific records are in the vColumn and it returns\",\n \"(ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias,\",\n \"method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format(\",\n \"simply not selecting it in the final generated SQL code. Note: Dropping a\",\n \"query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha,\",\n \"partition the TS. start_date: str / date, optional Input Start Date. For example,\",\n \"on. **style_kwds Any optional parameter to pass to the Matplotlib functions. Returns -------\",\n \"idea is simple: instead of moving # data around for processing, VerticaPy brings\",\n \"\\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this \\\" \\\"issue.\\\"\",\n \"events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query, )\",\n \"DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS\",\n \"= argv[2 * i] THEN argv[2 * i + 1] ... ELSE argv[n]\",\n \"query_result for item in sublist] # ---# def div(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError(\",\n \"See Also -------- vDataFrame[].bar : Draws the Bar Chart of vColumn based on\",\n \": CASE ... WHEN vColumn = argv[2 * i] THEN argv[2 * i\",\n \"and the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self\",\n \"Evidence (WOE) Table. It tells the predictive power of an independent variable in\",\n \"Number of elements to display. offset: int, optional Number of elements to skip.\",\n \"start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\"\",\n \"new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError(\",\n \"'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate : Computes\",\n \"ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events)\",\n \"width of the vColumns 1 and 2 bars. It is only valid if\",\n \"method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot(\",\n \"import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax,\",\n \"in each of the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start,\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the\",\n \"sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total\",\n \"2 in case of discretization using the method 'same_freq'\\\" ) count = self.count()\",\n \"value down to the next whole number ln : natural logarithm log :\",\n \"vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"of the input vColumn based on an aggregation. Parameters ---------- by: str, optional\",\n \"start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input\",\n \"/ date-like vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks'\",\n \"\\\", \\\"_\\\") .replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}',\",\n \"\\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias,\",\n \"set to True, draw a Step Plot. ax: Matplotlib axes object, optional The\",\n \"------- float var See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame can have\",\n \"\\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {}, \\\"regr_slope\\\":\",\n \"IS NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(),\",\n \"zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826\",\n \"length: int, unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices\",\n \"to partition the TS. start_date: str / date, optional Input Start Date. For\",\n \"not (isinstance(val, Iterable)): val = [val] val += list(args) check_types([(\\\"val\\\", val, [list])]) val\",\n \"permissions and # limitations under the License. # # |_ |~) _ _|\",\n \"the input functions. Parameters ---------- func: list List of the different aggregation. aad\",\n \"increase the time of the learning and scoring phases. xlim: tuple, optional Set\",\n \"\\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y: str, nbins:\",\n \"__ __ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\\",\n \"category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query += ( \\\" WHERE {} IS\",\n \"> 0: try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"]\",\n \"\\\\ / / / # \\\\/ / / # / / # /\",\n \"op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and\",\n \"will be transformed. Parameters ---------- to_replace: str Regular expression to replace. value: str,\",\n \"float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of:\",\n \"operation pow : number raised to the power of another number round :\",\n \"the vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\",\",\n \"True, the intervals will be closed on the right. Returns ------- vDataFrame self.parent\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {} for elem in\",\n \"method: str = \\\"auto\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the optimal vColumn bar width. Parameters\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int,\",\n \"unit. For example, it can be 'minute' 'hour'... start: bool, optional If set\",\n \"parent=self.parent, transformations=[item for item in self.transformations], catalog=self.catalog, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1],\",\n \"idx == 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx ==\",\n \"{}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes the statics\",\n \"greater or equals to 2 in case of discretization using the method 'topk'\\\"\",\n \"with {} as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean\",\n \"# / / # / / # \\\\ / # \\\\ / #\",\n \"be a list of at least one element to use to order the\",\n \"= None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters\",\n \"= round(h, 2) elif h > 0.0001: h = round(h, 4) elif h\",\n \"or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func ) ): max_floor = max( len(self.parent[column].transformations), max_floor\",\n \"kwargs[\\\"column\\\"] else: check = False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns +=\",\n \"kernel. nbins: int, optional Maximum number of points to use to evaluate the\",\n \"= \\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index',\",\n \"software # distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\",\n \"sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias)\",\n \"= self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column 'numcol' must be\",\n \"non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events)\",\n \"{}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif\",\n \"interval will be computed. nbins: int, optional Number of bins used for the\",\n \"in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format(\",\n \"the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif\",\n \"[top]} ) return top # ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies\",\n \"---------- by: str, optional vColumn to use to partition the data. bandwidth: float,\",\n \"self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to use a mean encoding\\\"\",\n \"and other statistical information. Parameters ---------- k: int, optional Number of most occurent\",\n \"used as categorical (No h will be picked or computed) nbins: int, optional\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe\",\n \"vColumn using multiple statistical aggregations: min, max, median, unique... depending on the input\",\n \"), print_time_sql=False, ) except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\",\",\n \"] elif method == \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method\",\n \"drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result +\",\n \"= [self.min()] + result + [self.max()] elif method == \\\"topk\\\": assert k >=\",\n \"approx else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---#\",\n \"kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"{0} ORDER BY COUNT(*) DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count >\",\n \"be sliced using the floor of the slicing instead of the ceiling. Returns\",\n \": Encodes the vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn.\",\n \"isinstance(xlim, (tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity(\",\n \"= False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of the\",\n \"> {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha,\",\n \"[ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ]\",\n \"Extracts a specific TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\", length,\",\n \"q% : q Quantile of the vColumn 'of' (ex: 50% to get the\",\n \"Chart of the input vColumns based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\",\",\n \"for elem in result if elem[1] != None ] ), ) stddev =\",\n \"+ 1] if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\"\",\n \"input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) #\",\n \"name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name' must not be empty\\\" ) assert not\",\n \"Forest on a response column to find the most relevant interval to use\",\n \"if not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax =\",\n \"method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({}\",\n \"the donut chart of the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type,\",\n \"category. See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return\",\n \"\\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a list of\",\n \"Mean for the numerical and Mode for the categorical vColumns. bfill : Back\",\n \"self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param,\",\n \"[tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date,\",\n \"Plot. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \"to the following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn.\",\n \"self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\") ]\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in each\",\n \"Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} )\",\n \"creating a copy with the specified name. \\\\u26A0 Warning : SQL code generation\",\n \": q Quantile of the vColumn 'of' (ex: 50% to get the median).\",\n \"See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isnum\",\n \"pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp\",\n \"end_date: str / date, optional Input End Date. For example, time = '03-11-1993'\",\n \"else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by)\",\n \"model_name = '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for\",\n \"1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"):\",\n \"\\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format(\",\n \"self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem\",\n \"Label Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response,\",\n \"of the bar. If empty, an optimized h will be computed. ax: Matplotlib\",\n \"k of the 'topk' method. new_category: str, optional The name of the merging\",\n \"= MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n == 1:\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int,\",\n \"changing the parameter 'new_name', you'll be able to solve this issue.\\\" ) self.add_copy(new_name)\",\n \"bool, optional If set to True, the lowest element of the list will\",\n \"check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division by 0 is forbidden\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]),\",\n \"from verticapy.plot import spider as spider_plot return spider_plot( self.parent, columns, method, of, max_cardinality,\",\n \"x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns\",\n \") for elem in sauv: if \\\"top\\\" in elem: if \\\"percent\\\" in elem:\",\n \"the a part of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist(\",\n \"# ---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in\",\n \"be able to solve this \\\" \\\"issue.\\\" ) for k in range(len(distinct_elements) -\",\n \"Diaconis and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n **\",\n \"import Line2D colors = gen_colors() if not xlim: xmin = self.min() xmax =\",\n \"is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\") # ---# def iv_woe(self, y:\",\n \"model.drop() raise # ---# def describe( self, method: str = \\\"auto\\\", max_cardinality: int\",\n \"of the search. Parameters ---------- val: list List of the different records. For\",\n \"pt_events, CASE WHEN non_events = 0 OR events = 0 THEN 0 ELSE\",\n \"\\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x,\",\n \"Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent See Also --------\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the\",\n \"result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol =\",\n \"use to aggregate the data. count : Number of elements. density : Percentage\",\n \"data transformation operations, and offers beautiful graphical options. # # VerticaPy aims to\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the category of the vColumn. The category will be one\",\n \"all_cols: try: if (quote_ident(column) in func) or ( re.search( re.compile(\\\"\\\\\\\\b{}\\\\\\\\b\\\".format(column.replace('\\\"', \\\"\\\"))), func )\",\n \"**style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std'\",\n \"is a Python library with scikit-like functionality for conducting # data science projects\",\n \"\\\"{}\\\"), \\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} -\",\n \"cbrt : cube root ceil : value up to the next whole number\",\n \"vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\",\",\n \"= [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as\",\n \"power of an independent variable in relation to the dependent variable. Parameters ----------\",\n \"of the dummies ({name}).\\\\n\\\" \\\"It can be the result of using previously the\",\n \"\\\\ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\\",\n \"\\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \"absolute value of the record is greater than the threshold, it will be\",\n \"THEN {} \\\".format(\\\"{}\\\", upper, upper) if (isinstance(upper, (float, int))) else \\\"\\\" ) func\",\n \"if method.lower() == \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h\",\n \"events = 0 THEN 0 ELSE (pt_non_events - pt_events) * ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))\",\n \"-------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using an\",\n \"vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int,\",\n \"of the current axes. ax: Matplotlib axes object, optional The axes to plot\",\n \"len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(),\",\n \"the different categories to [0, n - 1] (n being the vColumn cardinality).\",\n \"str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn(\",\n \"index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events =\",\n \"sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] -\",\n \"the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies.\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\",\",\n \"(is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*)\",\n \"return self elif (n == 1) and (self.parent[by[0]].nunique() < 50): try: result =\",\n \"{}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def spider(\",\n \"str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate : Computes the\",\n \"warnings.warn(warning_message, Warning) return self mad, med = self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if\",\n \"THEN {} \\\".format(\\\"{}\\\", lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when\",\n \"str, optional Response vColumn when method is set to 'smart'. return_enum_trans: bool, optional\",\n \"warnings.warn(warning_message, Warning) else: distinct_elements = self.distinct() expr = [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of the vColumn based on\",\n \"optional The describe method. auto : Sets the method to 'numerical' if the\",\n \"*argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv:\",\n \"] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(),\",\n \"\\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\",\",\n \": Returns True if the vColumn category is date. vDataFrame[].isnum : Returns True\",\n \"method: str = \\\"auto\\\", max_cardinality: int = 6, numcol: str = \\\"\\\" ):\",\n \"vColumn. abs : absolute value acos : trigonometric inverse cosine asin : trigonometric\",\n \"normalize. zscore : Normalization using the Z-Score (avg and std). (x - avg)\",\n \"(x - min) / (max - min) by: list, optional vColumns used in\",\n \"0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx] else: label\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---# def quantile(self,\",\n \"RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), (\\\"h\\\", h, [int, float]), (\\\"response\\\", response, [str]), (\\\"nbins\\\",\",\n \"name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s were\",\n \"deviation). Returns ------- float mad See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"if elem[1] != None else \\\"NULL\\\", ) for elem in result if elem[1]\",\n \"h: float, optional Interval width of the bar. If empty, an optimized h\",\n \"of vColumn distinct elements to be used as categorical. The less frequent elements\",\n \"/ TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See\",\n \"during the computation. n: int, optional Integer corresponding to the offset. For example,\",\n \"if not (dropna) and (pre_comp != None): return pre_comp assert n >= 1,\",\n \"undefined Returns ------- str vColumn category. See Also -------- vDataFrame[].ctype : Returns the\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS field\",\n \"upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha =\",\n \"if right: op1, op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1,\",\n \"'topk' method. new_category: str, optional The name of the merging category when using\",\n \"- sauv[\\\"approx_50%\\\"]) / ( 1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem]\",\n \"Parameters ---------- alias: str vColumn alias. transformations: list, optional List of the different\",\n \"function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x:\",\n \"Returns the head of the vColumn. vDataFrame[].tail : Returns the tail of the\",\n \"( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\"\",\n \"* FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except:\",\n \"the vColumn using 'std' (Standard Deviation). Returns ------- float std See Also --------\",\n \"def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn.\",\n \"the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters\",\n \"None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) / ( 1.4826\",\n \"tells the predictive power of an independent variable in relation to the dependent\",\n \"[] while total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total\",\n \"response, [str]), (\\\"nbins\\\", nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\",\",\n \"\\\"auto\\\"): if not (h) or h <= 0: if nbins <= 0: h\",\n \"executeSQL( query=query, title=\\\"Computing the average of the {}'s lower and upper outliers.\\\".format( self.alias\",\n \"not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent # ---#\",\n \"False, the function's performance can drastically decrease. Returns ------- float/str median See Also\",\n \"use to partition the data. h: float, optional Interval width if the vColumn\",\n \"if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100\",\n \"(self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {}) * {}\",\n \"= True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ----------\",\n \"outliers by their respective average. null : Replaces the outliers by the NULL\",\n \"_repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_() # ---# def __setattr__(self, attr, val): self.__dict__[attr] = val #\",\n \"= \\\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT NULL LIMIT\",\n \"operations, and offers beautiful graphical options. # # VerticaPy aims to do all\",\n \"parameter to pass to the Matplotlib functions. Returns ------- ax Matplotlib axes object\",\n \"TS (Time Series) vColumn to use to order the data. The vColumn type\",\n \"elements and their distributions as percents. Parameters ---------- k: int, optional Number of\",\n \"= \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def\",\n \"memorize the already computed aggregations to gain in performance. The catalog will be\",\n \"query = \\\"SELECT {} AS {} FROM {} WHERE {} IS NOT NULL\",\n \"the statics of {} partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query,\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.plot\",\n \"str, optional vColumn to use to partition the data. h: float, optional Interval\",\n \"executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min,\",\n \"to all the vColumns. vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" if isinstance(func,\",\n \"apply the function: x -> x^2 + 2 use \\\"POWER({}, 2) + 2\\\".\",\n \"f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the parameter 'new_name', you'll be\",\n \") setattr(self.parent, name, new_vColumn) setattr(self.parent, name[1:-1], new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] self.parent.__add_to_history__( \\\"[Add Copy]:\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"------- float aad See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"vColumn. vDataFrame[].str_replace : Replaces the regular expression matches in each of the vColumn\",\n \"of the vColumn 'of'. min : Minimum of the vColumn 'of'. max :\",\n \"enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) )\",\n \"WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias,\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"variance\\\"]).values[self.alias][0]\",\n \"TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent See Also\",\n \"(PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({},\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\"))\",\n \"trans = \\\"(CASE \\\" for i in range(1, n): trans += \\\"WHEN {}\",\n \"the vColumn category is date. vDataFrame[].isnum : Returns True if the vColumn is\",\n \"bool, optional If set to True, NULL values will not be considered during\",\n \") except: pass total = int(total) conj = \\\"s were \\\" if total\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density Plot. Parameters ---------- by:\",\n \"h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\"\",\n \"AS Q1, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.75) AS Q3, MAX({}) AS max\",\n \"return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax, **style_kwds) # ---# def category(self): \\\"\\\"\\\"\",\n \"not apply it. This parameter is very useful for testing to be able\",\n \"func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor =\",\n \"number of points to use to evaluate the approximate density function. Increasing this\",\n \"\\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr) # ---#\",\n \"---# def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str,\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies\",\n \"({}) x ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE &\",\n \"implied. # See the License for the specific language governing permissions and #\",\n \"used are the median and two input quantiles. Parameters ---------- ts: str TS\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"aggregation. h: int/float/tuple, optional Interval width of the vColumns 1 and 2 bars.\",\n \"will be transformed. Parameters ---------- pat: str Regular expression. Returns ------- vDataFrame self.parent\",\n \"the method is in ffill|pad|bfill|backfill then 'order_by' must be a list of at\",\n \"BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, )\",\n \"method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, h:\",\n \"categories of {}.\\\".format( k if k > 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\",\",\n \"vDataFrame[].isdate : Returns True if the vColumn category is date. \\\"\\\"\\\" return self.category()\",\n \"vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count, is_numeric, is_date = (\",\n \"the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies\",\n \"xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn Density\",\n \"one of the dummies ({name}).\\\\n\\\" \\\"It can be the result of using previously\",\n \"descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for\",\n \"{}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts\",\n \"of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent\",\n \"raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format( e, self.alias,\",\n \"2 in case of discretization using the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"]\",\n \"- {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev ),\",\n \"self.parent # ---# def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float =\",\n \"return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"of the vColumn 'of'. sum : Sum of the vColumn 'of'. q% :\",\n \"function floor : value down to the next whole number ln : natural\",\n \"by == []: if fun == \\\"AVG\\\": val = self.avg() elif fun ==\",\n \"empty, an optimized h will be computed. ax: Matplotlib axes object, optional The\",\n \"to aggregate the data. count : Number of elements. density : Percentage of\",\n \"using an advanced analytical function on a specific vColumn. \\\"\\\"\\\" return self.parent.aggregate(func=func, columns=[self.alias]).transpose()\",\n \"\\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY COUNT(*)\",\n \"encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans, [bool]),\",\n \"= self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func) or\",\n \"# ---# def isnum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical,\",\n \"2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not empty, a\",\n \"bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of\",\n \"of nbins. If empty, an optimized number of nbins will be computed. h:\",\n \"except: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE {} IS\",\n \"list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the vColumn with\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters ---------- argv: object\",\n \"kurtosis See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"), title=\\\"Computing the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)):\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---#\",\n \"None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else\",\n \"ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK / YEAR Returns ------- vDataFrame self.parent\",\n \"method. new_category: str, optional The name of the merging category when using the\",\n \"See Also -------- vDataFrame.case_when : Creates a new feature by evaluating some conditions.\",\n \"# See the License for the specific language governing permissions and # limitations\",\n \"GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories\",\n \"kwargs): from verticapy.plot import gen_cmap kwargs[\\\"cmap\\\"] = gen_cmap()[0] else: if not (\\\"color\\\" in\",\n \": Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.category() == \\\"date\\\"\",\n \"self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message, Warning) elif self.isnum(): if\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record of the vColumn.\",\n \"the computation. cat_stats : Computes statistics of a numerical column for each vColumn\",\n \"AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to plot on.\",\n \"THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i] )\",\n \"elem in self.transformations] total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor\",\n \"\\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if approx\",\n \"/ / / # \\\\/ / / # / / # / /\",\n \"of most occurent elements to return. Returns ------- tablesample An object containing the\",\n \"PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT\",\n \"\\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {}\",\n \"using the following mapping:{}\\\".format( self.alias, text_info ) ) return self.parent # ---# def\",\n \"start_date, [str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date,\",\n \"optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of the dummies.\",\n \"to the vDataFrame by using an advanced analytical function on a specific vColumn.\",\n \"= verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if\",\n \"method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif method ==\",\n \"- limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {} AS {}\",\n \"IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1]\",\n \"in elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem == None:\",\n \"be picked or computed) nbins: int, optional Number of bins. If empty, an\",\n \"other categories will be filtered. ax: Matplotlib axes object, optional The axes to\",\n \"h = round(h, 2) elif h > 0.0001: h = round(h, 4) elif\",\n \"optimal vColumn bar width. Parameters ---------- method: str, optional Method to use to\",\n \"Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent\",\n \"bins. If empty, an optimized number of bins will be computed. h: float,\",\n \"== \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) ==\",\n \"the different categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2]\",\n \"= (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or\",\n \"1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent See Also --------\",\n \"------- float sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"top # ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by\",\n \"str = \\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\"\",\n \") ) return self.parent # ---# def fillna( self, val=None, method: str =\",\n \"See Also -------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])])\",\n \"( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] =\",\n \"Geospatial object. Parameters ---------- *args / **kwargs Any optional parameter to pass to\",\n \"in the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An\",\n \"{} AS percent FROM {}{} GROUP BY {} ORDER BY _verticapy_cnt_ DESC {}\\\".format(\",\n \"/ ({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({} - {}) /\",\n \"self.alias ) warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if n ==\",\n \"close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest:\",\n \"(must be > 1) Returns ------- tablesample An object containing the result. For\",\n \"sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) +\",\n \"Also -------- vDataFrame[].apply : Applies a function to the vColumn. \\\"\\\"\\\" check_types( [\",\n \"aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]),\",\n \"dtype = ctype # ---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a\",\n \"{}.\\\".format(self.alias), method=\\\"fetchall\\\", ) return [item for sublist in query_result for item in sublist]\",\n \"\\\\/ # / # VerticaPy is a Python library with scikit-like functionality for\",\n \"to use when the parameter method is set to 'cat_stats'. Returns ------- tablesample\",\n \"instead of the parent vDataFrame. This parameter is used for testing purpose. Returns\",\n \"{op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\" WHEN\",\n \"!= None), ParameterError( \\\"At least 'lower' or 'upper' must have a numerical value\\\"\",\n \"!= \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The column\",\n \"/ / / # \\\\ / / / # \\\\/ / / #\",\n \"\\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater or equals\",\n \"\\\"At least 'lower' or 'upper' must have a numerical value\\\" ) lower_when =\",\n \"result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] += [\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return\",\n \"_ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______\",\n \"), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert nbins >=\",\n \"rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS\",\n \"\\\"regr_slope\\\": {}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog:\",\n \"Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt\",\n \"return self.parent # ---# def median( self, approx: bool = True, ): \\\"\\\"\\\"\",\n \"\\\"\\\" ) func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent\",\n \"[bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf(\",\n \"in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item\",\n \"vColumn with user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes\",\n \"min : Minimum of the vColumn 'of'. max : Maximum of the vColumn\",\n \"Q1. approx: bool, optional If set to True, the approximate quantile is returned.\",\n \"function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\",\",\n \"kernel. sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum\",\n \"median( self, approx: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"parameter 'numcol' must be a vDataFrame column if the method is 'cat_stats'\\\" )\",\n \"\\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not normalize {} using a\",\n \"int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0]\",\n \"WHEN non_events = 0 OR events = 0 THEN 0 ELSE (pt_non_events -\",\n \"# ---# def mode(self, dropna: bool = False, n: int = 1): \\\"\\\"\\\"\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0]\",\n \"new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif method in (\\\"mean\\\", \\\"avg\\\", \\\"median\\\"): fun\",\n \"lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values lesser than\",\n \"({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format(\",\n \"(\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or (\",\n \"index = result.values[\\\"index\\\"] result = result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol !=\",\n \"( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name)\",\n \"vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a\",\n \"/ (max - min) by: list, optional vColumns used in the partition. return_trans:\",\n \"else \\\" WHERE {} = '{}'\\\".format( bin_spatial_to_str(self.category(), self.alias), category, ) ) query +=\",\n \"== \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\",\",\n \"Start of the slicing. step: int Size of the slicing. Returns ------- vDataFrame\",\n \"the next whole number ln : natural logarithm log : logarithm log10 :\",\n \"elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args,\",\n \": Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') >\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({})\",\n \"# ---# def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n\",\n \"threshold ) ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias])\",\n \") + \\\".\\\" ) return self.parent one_hot_encode = get_dummies # ---# def head(self,\",\n \"vColumn labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method,\",\n \"self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not (method == \\\"categorical\\\"): result =\",\n \"(self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\" ):\",\n \"return hist(self, method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self,\",\n \"{} AS {}, {} AS verticapy_agg FROM {} WHERE {} IS NOT NULL\",\n \"= True, alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the\",\n \"# # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average\",\n \"self.category() == \\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a user-defined\",\n \"= 0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%',\",\n \"Input End Date. For example, time = '03-11-1993' will filter the data when\",\n \"# \\\\/ / / # / / # / / # \\\\ /\",\n \"density( self, by: str = \\\"\\\", bandwidth: float = 1.0, kernel: str =\",\n \"int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n smallest elements in the vColumn.\",\n \"columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able\",\n \"the vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex: 50%\",\n \"'hour'... start: bool, optional If set to True, the record will be sliced\",\n \"from verticapy.toolbox import * from verticapy.errors import * ## # # __ __\",\n \"to use to partition the data. bandwidth: float, optional The bandwidth of the\",\n \"std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float\",\n \"class vColumn(str_sql): \\\"\\\"\\\" --------------------------------------------------------------------------- Python object which that stores all user transformations. If\",\n \": Uses the Random Forest on a response column to find the most\",\n \"return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) ) #\",\n \"Percentage of the distribution. mean : Average of the vColumn 'of'. min :\",\n \"to True, draw an Area Plot. step: bool, optional If set to True,\",\n \"bound to the lower bound itself and the values higher than the upper\",\n \"if the vColumns are numerical. Optimized h will be computed if the parameter\",\n \"list = [], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements\",\n \"exponential function floor : value down to the next whole number ln :\",\n \"if \\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS {} FROM {}\",\n \"the Median will be drawn. ax: Matplotlib axes object, optional The axes to\",\n \"\\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category,\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.boxplot :\",\n \"= self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition =\",\n \"be drawn. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds\",\n \"if self.category() == \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category()\",\n \": Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self)\",\n \"points to use to evaluate the approximate density function. Increasing this parameter will\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = (\",\n \"to sort the data when using TS methods. Returns ------- vDataFrame self.parent See\",\n \"vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn. Parameters ---------- limit: int, optional\",\n \"= 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"_ __|_. _ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/ # /\",\n \"Converts the vColumn to the input type. Parameters ---------- dtype: str New type.\",\n \"= quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has\",\n \"rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with\",\n \"vColumns 1 and 2 to be used as categorical (No h will be\",\n \"in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype,\",\n \"int, unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the input element. Parameters ----------\",\n \"+ sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total +=\",\n \"mod : remainder of a division operation pow : number raised to the\",\n \"catalog: dict, optional Catalog where each key corresponds to an aggregation. vColumns will\",\n \"# ---# def fillna( self, val=None, method: str = \\\"auto\\\", expr: str =\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self):\",\n \"item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose()\",\n \") category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols:\",\n \"vColumns.\\\" ) assert len(breaks) >= 2, ParameterError( \\\"Length of parameter 'breaks' must be\",\n \"{} using a Z-Score - The Standard Deviation is null !\\\".format( self.alias )\",\n \"ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not\",\n \"------- ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar\",\n \"if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x))\",\n \"with user defined Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode\",\n \"DOW / DOY / EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR\",\n \"\\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"/ Weight Of Evidence (WOE) Table. It tells the predictive power of an\",\n \": Drops outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled\",\n \"using 'sem' (standard error of mean). Returns ------- float sem See Also --------\",\n \"vColumn outliers. mean : Replaces the upper and lower outliers by their respective\",\n \"Parameters ---------- func: str, Function in pure SQL used to transform the vColumn.\",\n \"\\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", )\",\n \"------- int vColumn expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the\",\n \"limit = 0 limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query\",\n \"the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division\",\n \"= 0, max_cardinality: int = 8, cat_priority: list = [], ax=None, **style_kwds, ):\",\n \"AS events FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y, query, )\",\n \"ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return\",\n \"function. Increasing this parameter will increase the precision but will also increase the\",\n \"alpha: float = 0.05 ): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops outliers in the vColumn. Parameters\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks: list\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"picked or computed) ax: Matplotlib axes object, optional The axes to plot on.\",\n \"None: new_column = \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr)\",\n \"True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x:\",\n \"\\\"[Mean Encode]: The vColumn {} was transformed using a mean encoding with {}\",\n \"!= None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format(\",\n \"equal to 0, an optimised interval will be computed. nbins: int, optional Number\",\n \"\\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] ) if func not\",\n \"vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements. \\\"\\\"\\\"\",\n \"total > 1 else \\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__(\",\n \": Jarque-Bera index mad : median absolute deviation max : maximum mean :\",\n \"\\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC\",\n \"|_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # / __ `\\\\ / /\",\n \"approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str\",\n \"renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self, n: int): \\\"\\\"\\\"\",\n \"pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self, to_replace: str, value: str = \\\"\\\"):\",\n \"**style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn\",\n \"catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame : Parent of the\",\n \"ffill : Propagation of the first element (Constant Interpolation). mean : Average. median\",\n \"1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for\",\n \"float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist\",\n \"invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for vColumns 1 and\",\n \"vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])])\",\n \"']'\\\".format( \\\"{}\\\", h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", )\",\n \"vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding\",\n \"= 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END\",\n \"numerical aggregations during the computation. max_cardinality: int, optional Cardinality threshold to use to\",\n \"returns the new vDataFrame of the search. Parameters ---------- val: list List of\",\n \"{}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {}, \\\"regr_count\\\": {}, \\\"regr_intercept\\\": {}, \\\"regr_r2\\\": {},\",\n \"self.iloc(limit=limit, offset=-1) # ---# def topk(self, k: int = -1, dropna: bool =\",\n \"quantile(1-alpha) will be filled. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].drop_outliers :\",\n \"1.4826 * sauv[\\\"mad\\\"] ) elif method == \\\"zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"])\",\n \"kurtosis # ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection\",\n \"self.parent.__add_to_history__( \\\"[Drop]: vColumn {} was deleted from the vDataFrame.\\\".format(self.alias) ) return parent #\",\n \"use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot\",\n \"\\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query,\",\n \"= ( \\\"label_encode is only available for categorical variables.\\\" ) warnings.warn(warning_message, Warning) else:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in the vColumn and it\",\n \"of the vColumn records. vDataFrame[].str_count : Computes the number of matches for the\",\n \"in enumerate(result): result[idx][0] = ( \\\"NULL\\\" if (elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\"))\",\n \"input element from the vColumn. Parameters ---------- x: float If the vColumn type\",\n \"vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate :\",\n \"AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result =\",\n \"def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the values\",\n \"value{} filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\")\",\n \"be considered as categorical. numcol: str, optional Numerical vColumn to use when the\",\n \"field from the vColumn (only if the vColumn type is date like). The\",\n \"AS {} FROM {}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT\",\n \"vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode\",\n \"AS {}, {} AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias,\",\n \"the 2 quantiles used to draw the Plot. start_date: str / date, optional\",\n \"Drops the vColumn missing values. \\\"\\\"\\\" if isinstance(by, str): by = [by] if\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\"\",\n \"idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label = labels[idx]\",\n \"= 1.0, kernel: str = \\\"gaussian\\\", nbins: int = 200, xlim: tuple =\",\n \"func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def\",\n \"Each transformation must be similar to the following: (function, type, category) parent: vDataFrame,\",\n \"(method != \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ): query =\",\n \"will be stored in the vDataFrame history. Returns ------- vDataFrame self.parent See Also\",\n \"max_cardinality, [int, float]), (\\\"h\\\", h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] )\",\n \"date, False otherwise. Returns ------- bool True if the vColumn category is date.\",\n \"a new vColumn labeled with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\"\",\n \"optional Maximum number of vColumn distinct elements to be used as categorical. The\",\n \"density function. Increasing this parameter will increase the precision but will also increase\",\n \"See Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\",\",\n \"See Also -------- vDataFrame[].isbool : Returns True if the vColumn is boolean. vDataFrame[].isdate\",\n \"self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique() <\",\n \"[str]), ] ) method = method.lower() assert (method != \\\"cat_stats\\\") or (numcol), ParameterError(\",\n \"by grouping by elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return\",\n \"int = 0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"encoding with {} as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The\",\n \"different records. For example, to check if Badr and Fouad are in the\",\n \"smallest elements in the vColumn. Parameters ---------- n: int, optional Offset. Returns -------\",\n \"or computed) h: float, optional Interval width of the bar. If empty, an\",\n \"unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices and transforms\",\n \"- {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({} -\",\n \"Table. It tells the predictive power of an independent variable in relation to\",\n \"** (1 / 3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float\",\n \"ints and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10}\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s were \\\" if len(all_new_features)\",\n \"\\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) )\",\n \"'{}' was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"= get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for column in all_cols: try: if\",\n \"!= \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh is only available\",\n \"(\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result =\",\n \"axes object See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn\",\n \"\\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem\",\n \"-------- vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])])\",\n \"[str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") ) )\",\n \"10} to train a Random Forest with 20 trees and a maximum depth\",\n \"Draws the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use\",\n \"decimal places sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic\",\n \"== \\\"int\\\": h = int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\")\",\n \"by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method = \\\"mean\\\" if (self.isnum()\",\n \"--------------------------------------------------------------------------- Verifies if the regular expression is in each of the vColumn records.\",\n \"expression is in each of the vColumn records. vDataFrame[].extract : Extracts the regular\",\n \"'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using an input 'quantile'. Parameters ---------- x: float A\",\n \"xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0], [0],\",\n \"[cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"h\\\", h, [int,\",\n \"\\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by,\",\n \") executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype,\",\n \"= by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for\",\n \"--------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters ---------- by: str, optional\",\n \"the n largest vColumn elements. Parameters ---------- n: int, optional Offset. Returns -------\",\n \"{}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\", \\\"median\\\") or isinstance(val,\",\n \"the vColumn. One vDataFrame can have multiple children vColumns whereas one vColumn can\",\n \"nbins, [int, float]), ( \\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\",\",\n \"to use to partition the data. method: str, optional The method to use\",\n \"method == \\\"topk\\\": assert k >= 2, ParameterError( \\\"Parameter 'k' must be greater\",\n \"not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr =\",\n \"= \\\"\\\", bandwidth: float = 1.0, kernel: str = \\\"gaussian\\\", nbins: int =\",\n \"\\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---#\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"sum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head\",\n \"return pre_comp store_usage = executeSQL( \\\"SELECT ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ),\",\n \"bool, optional Returns the transformation instead of the vDataFrame parent and do not\",\n \"lesser than quantile(alpha) or greater than quantile(1-alpha) will be filled. Returns ------- vDataFrame\",\n \"user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].get_dummies : Encodes the vColumn\",\n \": Computes bins with the same number of elements. same_width : Computes regular\",\n \"for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name,\",\n \"use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format(\",\n \"[], order_by: list = [], ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills missing elements in the\",\n \"mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query, title=\\\"Computing the average\",\n \"the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a\",\n \"= [\\\"unique\\\", \\\"count\\\"] + [item[0] for item in query_result] else: result = (\",\n \"the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame The vDataFrame of the search.\",\n \"result = executeSQL( query, title=\\\"Computing the top{} categories of {}.\\\".format( k if k\",\n \"\\\"text\\\", ) elif self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError(\",\n \"not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not\",\n \"---------- prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor\",\n \"---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn.\",\n \"\\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ]\",\n \"analytics and machine learning features. It supports the # entire data science life\",\n \"/ / # \\\\_______/ / / # ______ / / # \\\\ /\",\n \"if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {},\",\n \"title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", ) if method == \\\"winsorize\\\": self.clip(lower=p_alpha, upper=p_1_alpha)\",\n \"the input type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method,\",\n \"LIMIT 1\\\".format( alpha, self.alias, alpha, self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query,\",\n \"rounds a value to a specified number of decimal places sign : arithmetic\",\n \"the vColumn is numerical, False otherwise. Returns ------- bool True if the vColumn\",\n \"times, so it's better practice to use this method when first preparing your\",\n \"- {}) WITHIN GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format(\",\n \"stored in Vertica, taking advantage Vertica’s # speed and built-in analytics and machine\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\",\",\n \"verticapy.errors import * ## # # __ __ ______ ______ __ __ __\",\n \"|_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ # / __ `\\\\ /\",\n \"(\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ]\",\n \"fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {}\",\n \"See Also -------- vDataFrame[].head : Returns the head of the vColumn. \\\"\\\"\\\" return\",\n \"custom_lines += [ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\")\",\n \"---# def pie( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality:\",\n \"\\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_____/ \\\\/_/\",\n \"the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].get_dummies : Encodes\",\n \"using the input list. Parameters ---------- breaks: list List of values used to\",\n \"set to True, the lowest element of the list will be included. right:\",\n \"It tells the predictive power of an independent variable in relation to the\",\n \"result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2) + 2)), 1e-99,\",\n \"and Mode for the categorical vColumns. bfill : Back Propagation of the next\",\n \"and std). (x - avg) / std robust_zscore : Normalization using the Robust\",\n \"cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation = [\",\n \"the 'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values lesser\",\n \"Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest with 20 trees\",\n \"except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result = [self.min()]\",\n \"the data using the input expression. \\\"\\\"\\\" self.parent.filter(\\\"{} IS NOT NULL\\\".format(self.alias)) return self.parent\",\n \"the vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also --------\",\n \"top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---#\",\n \"int, optional Number of most occurent elements to return. Returns ------- tablesample An\",\n \"ax = self.parent.search( \\\"{} = '{}'\\\".format(self.parent[by].alias, column) )[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax),\",\n \"= 8, cat_priority: list = [], ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"list, optional vColumns used in the partition. order_by: list, optional List of the\",\n \"to the data. # # # Modules # # Standard Python Modules import\",\n \"order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY {}))\\\".format( \\\"{}\\\",\",\n \"index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if index_start <\",\n \"{}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\": {},\",\n \"practice to use this method when first preparing your data. Parameters ---------- new_name:\",\n \"{} IS NOT NULL GROUP BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias,\",\n \"n) return to_tablesample(query, title=title) # ---# def normalize( self, method: str = \\\"zscore\\\",\",\n \"---------- func: str, Function in pure SQL used to transform the vColumn. The\",\n \"0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events\",\n \"{} IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"vColumn is numerical, False otherwise. Returns ------- bool True if the vColumn is\",\n \"of parameter breaks must be equal to the length of parameter 'labels' +\",\n \"Returns ------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes\",\n \"int, optional Number of elements to skip. Returns ------- tablesample An object containing\",\n \"\\\\ / # \\\\ / # \\\\/ # _ # \\\\ / _\",\n \"is empty or invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements\",\n \"donut = True if pie_type == \\\"donut\\\" else False rose = True if\",\n \"self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density( self, by: str = \\\"\\\", bandwidth: float\",\n \"< max_cardinality + 1) and (method != \\\"numerical\\\")) or not (is_numeric) or (method\",\n \"val # # Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"int = 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a part of\",\n \"when the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias.\",\n \"prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else 0\",\n \"several processes with its abstractions. Parameters ---------- alias: str vColumn alias. transformations: list,\",\n \"missing value{} filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was\",\n \"verticapy.plot import gen_colors from matplotlib.lines import Line2D colors = gen_colors() if not xlim:\",\n \"3)] sturges : Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width.\",\n \"use to convert the vColumn. If this parameter is equal to 0, an\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---# def label_encode(self): \\\"\\\"\\\"\",\n \"None ] ), ) executeSQL( \\\"SELECT {}, {} FROM {} LIMIT 1\\\".format( avg,\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot return spider_plot(\",\n \"or 'upper' must have a numerical value\\\" ) lower_when = ( \\\"WHEN {}\",\n \"a Random Forest with 20 trees and a maximum depth of 10. response:\",\n \"by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias]\",\n \"xmin, xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column\",\n \"to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses numbers as\",\n \"\\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) )\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/ \\\\/_____/\",\n \"str : vColumn alias. catalog, dict : Catalog of pre-computed aggregations. parent, vDataFrame\",\n \"self.transformations += [(new_column, ctype, category)] try: sauv = {} for elem in self.catalog:\",\n \"quantiles used to draw the Plot. start_date: str / date, optional Input Start\",\n \"when 'ts' is greater than November 1993 the 3rd. plot_median: bool, optional If\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar(\",\n \"cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\",\",\n \"the vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\",\",\n \"in self.catalog: total += sys.getsizeof(elem) return total # ---# def min(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if the vColumn\",\n \"filter the data when 'ts' is lesser than November 1993 the 3rd. end_date:\",\n \"[ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog = self.catalog\",\n \"None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {} THEN {} WHEN\",\n \"[\\\"\\\"] result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"to use to partition the TS. start_date: str / date, optional Input Start\",\n \"the vColumn records. vDataFrame[].extract : Extracts the regular expression in each record of\",\n \": rounds a value to a specified number of decimal places sign :\",\n \"+= nb where = \\\"WHERE _verticapy_row_nb_ IN ({})\\\".format( \\\", \\\".join([\\\"1\\\"] + nth_elems +\",\n \"\\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\",\",\n \"--------------------------------------------------------------------------- Discretizes the vColumn using the input method. Parameters ---------- method: str, optional\",\n \"self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\",\",\n \"-1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h > 1) or (self.category()\",\n \"+= \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return\",\n \"- {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0], threshold ) ) else:\",\n \"OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query = \\\"SELECT\",\n \"value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\", \\\"''\\\"), value.replace(\\\"'\\\", \\\"''\\\") )\",\n \"kernel.lower() from verticapy.learn.neighbors import KernelDensity schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema =\",\n \"True if the vColumn category is date, False otherwise. Returns ------- bool True\",\n \"0: if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation\",\n \"sauv: self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\"\",\n \"the vDataFrame represents the entire relation, a vColumn can be seen as one\",\n \"result.values[\\\"iv\\\"] += [sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"floor : value down to the next whole number ln : natural logarithm\",\n \"logarithm log10 : base 10 logarithm mod : remainder of a division operation\",\n \"---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str\",\n \"vColumn means simply not selecting it in the final generated SQL code. Note:\",\n \"is greater than November 1993 the 3rd. area: bool, optional If set to\",\n \"1) and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun = \\\"APPROXIMATE_MEDIAN\\\"\",\n \"= \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k)\",\n \"h, [int, float]), (\\\"nbins\\\", nbins, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of\",\n \"to use to transform the vColumn. abs : absolute value acos : trigonometric\",\n \"method == \\\"minmax\\\": if n == 0: nullifzero = 0 cmin, cmax =\",\n \"\\\\ # \\\\ \\\\ \\\\'/ \\\\ \\\\ \\\\____ \\\\ \\\\ \\\\/\\\\ \\\\ \\\\\",\n \"parameter breaks must be equal to the length of parameter 'labels' + 1\",\n \"Average. median : median. mode : mode (most occurent element). 0ifnull : 0\",\n \"bool, optional If set to True, draw a Step Plot. ax: Matplotlib axes\",\n \"some conditions. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with\",\n \"\\\"min\\\", \\\"approx_25%\\\", \\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values = {\",\n \"1) and (method != \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ):\",\n \"elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS {}\",\n \"self.parent # ---# def fillna( self, val=None, method: str = \\\"auto\\\", expr: str\",\n \"def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB type. Returns ------- str vColumn\",\n \"'numcol' must be a vDataFrame column if the method is 'cat_stats'\\\" ) distinct_count,\",\n \"MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME\",\n \"created using the input Name. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.apply\",\n \": Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\"))\",\n \"caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most\",\n \"the head of the vColumn. vDataFrame[].tail : Returns the tail of the vColumn.\",\n \"/ nbins if h > 0.01: h = round(h, 2) elif h >\",\n \"isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean, False otherwise. Returns\",\n \"= gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\"\",\n \"the bar. If empty, an optimized h will be computed. pie_type: str, optional\",\n \"> 1) or (self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} /\",\n \"str Response vColumn. nbins: int, optional Maximum number of nbins used for the\",\n \"vColumn using 'sum'. Returns ------- float sum See Also -------- vDataFrame.aggregate : Computes\",\n \"or (self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {}) *\",\n \"to display. Returns ------- tablesample An object containing the result. For more information,\",\n \"self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int = 5): \\\"\\\"\\\"\",\n \"y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y) y = self.parent.format_colnames(y) assert self.parent[y].nunique() == 2,\",\n \"0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast,\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as e: self.transformations =\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {})\",\n \"if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {} < {}\",\n \"ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format(\",\n \"20, \\\"max_depth\\\": 8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response)\",\n \"a copy vColumn to the parent vDataFrame. Parameters ---------- name: str Name of\",\n \"average of the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ]\",\n \"math, re, decimal, warnings, datetime from collections.abc import Iterable from typing import Union\",\n \"parameter 'labels' must be empty.\\\" ) conditions, column = [], self.alias for idx\",\n \"ALL \\\".join(query) ) title = \\\"Describes the statics of {} partitioned by {}.\\\".format(\",\n \"UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple]\",\n \"nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines += [ Line2D( [0],\",\n \"len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column,\",\n \"float, optional The bandwidth of the kernel. kernel: str, optional The method used\",\n \"be a cutomized aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional\",\n \"var : variance Other aggregations could work if it is part of the\",\n \"'minute' 'hour'... start: bool, optional If set to True, the record will be\",\n \": Uses method 'same_width' for numerical vColumns, cast the other types to varchar.\",\n \"columns = [self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of =\",\n \"was successfully done.\\\") return self.parent # ---# def median( self, approx: bool =\",\n \"used to draw the Plot. start_date: str / date, optional Input Start Date.\",\n \"different categories to consider when drawing the box plot. The other categories will\",\n \"= [elem[0] for elem in result] elif self.isnum() and method in (\\\"same_width\\\", \\\"auto\\\"):\",\n \"def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the\",\n \"method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name) model.set_params({\\\"n_estimators\\\":\",\n \"/ # | \\\\/ / / / # |______ / / / #\",\n \"Computes the vColumn descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])])\",\n \"the vColumn category is date, False otherwise. Returns ------- bool True if the\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the\",\n \"[int, float])]) query = \\\"SELECT * FROM {} WHERE {} IS NOT NULL\",\n \"the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct\",\n \"higher than the upper bound to the upper bound itself. Parameters ---------- lower:\",\n \"cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor =\",\n \"fun, self.alias, self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the different aggregations.\\\",\",\n \"Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.bar :\",\n \"Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) return\",\n \"__ # /\\\\ \\\\ / / /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\\",\n \"1) Returns ------- tablesample An object containing the result. For more information, see\",\n \"result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias,\",\n \"pie_type: str, optional The type of pie chart. auto : Regular pie chart.\",\n \"THEN {} WHEN {} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha,\",\n \"order_by, ParameterError( \\\"If the method is in ffill|pad|bfill|backfill then 'order_by' must be a\",\n \"BY 1) x ORDER BY verticapy_agg DESC\\\".format( self.alias, bin_spatial_to_str(self.category(), self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(),\",\n \"can not be converted to {}\\\".format( e, self.alias, dtype ) ) # ---#\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from\",\n \"natural logarithm log : logarithm log10 : base 10 logarithm mod : remainder\",\n \"vColumns outliers using the input method. Parameters ---------- method: str, optional Method to\",\n \"if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": if\",\n \"Keeps the topk most frequent categories and merge the other into one unique\",\n \"elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"): assert order_by, ParameterError( \\\"If the method\",\n \"== \\\"mode\\\") and (val == None): val = self.mode(dropna=True) if val == None:\",\n \"] ) method = method.lower() if self.isnum() and method == \\\"smart\\\": schema =\",\n \"equal to the length of parameter 'labels' + 1 or parameter 'labels' must\",\n \"the record is greater than the threshold it will be considered as an\",\n \"applicable law or agreed to in writing, software # distributed under the License\",\n \"the vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object\",\n \"available only if the parameter 'by' is empty\\\\nIf you want to normalize by\",\n \"AS count, 100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4})\",\n \"describe method. auto : Sets the method to 'numerical' if the vColumn is\",\n \"Upper bound. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].fill_outliers : Fills the\",\n \"\\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2} AS\",\n \"and method == \\\"smart\\\" ): n = len(result) trans = \\\"(CASE \\\" for\",\n \"lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha == None:\",\n \"float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = (\",\n \"[\\\"top{}\\\".format(n)], self.alias: [top]} ) return top # ---# def mul(self, x: float): \\\"\\\"\\\"\",\n \"if (method == \\\"mode\\\") and (val == None): val = self.mode(dropna=True) if val\",\n \"[\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage # ---# def str_contains(self, pat: str): \\\"\\\"\\\"\",\n \"The bandwidth of the kernel. kernel: str, optional The method used for the\",\n \"\\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and method\",\n \"AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn is boolean. See Also -------- vDataFrame[].isdate : Returns True if the vColumn\",\n \"the vColumn. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value,\",\n \"( \\\"'[' || FLOOR({} / {}) * {} || ';' || (FLOOR({} /\",\n \"BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE & IV of {}\",\n \"the vDataFrame history. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the\",\n \"ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL\",\n \"able to look at the final transformation. Returns ------- vDataFrame self.parent See Also\",\n \"NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type\",\n \"projects on data stored in Vertica, taking advantage Vertica’s # speed and built-in\",\n \"True if pie_type == \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of)\",\n \"import math, re, decimal, warnings, datetime from collections.abc import Iterable from typing import\",\n \"median, unique... depending on the input method. Parameters ---------- method: str, optional The\",\n \"parameter 'name' must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn\",\n \"\\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"Draws the Bar Chart of the input vColumns based on an aggregation. \\\"\\\"\\\"\",\n \"represents the second argument. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply :\",\n \"'cat_stats'. Returns ------- tablesample An object containing the result. For more information, see\",\n \"[\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]), ] )\",\n \"] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"]\",\n \"OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev =\",\n \"trans += \\\"WHEN {} BETWEEN {} AND {} THEN '[{};{}]' \\\".format( \\\"{}\\\", result[i\",\n \"1) query = \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query\",\n \"If set to True, NULL values will not be considered during the computation.\",\n \"return self.aggregate([\\\"min\\\"]).values[self.alias][0] # ---# def mode(self, dropna: bool = False, n: int =\",\n \"return the transformation used instead of the parent vDataFrame. This parameter is used\",\n \"avg(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average\",\n \"Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes the\",\n \"\\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({}\",\n \"the data when 'ts' is lesser than November 1993 the 3rd. end_date: str\",\n \"[name] all_new_features += [name] conj = \\\"s were \\\" if len(all_new_features) > 1\",\n \") if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import hist return hist(self,\",\n \"vColumns categories. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the\",\n \"AS count\\\" \\\" FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0}\",\n \"return pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) #\",\n \"list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk : Returns the\",\n \"used for testing purpose. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.outliers :\",\n \"{})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column = \\\"DECODE({}, NULL, 0, 1)\\\" elif\",\n \"self.clip(lower=p_alpha, upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND\",\n \"to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations )\",\n \"end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\",\",\n \"q Quantile of the vColumn 'of' (ex: 50% to get the median). It\",\n \"based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [\",\n \"vColumn using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also --------\",\n \"/ / # _____________ / / # \\\\ / / / # \\\\\",\n \"self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt = kurtosis # ---#\",\n \"max_cardinality: int = 6, h: float = 0, pie_type: str = \\\"auto\\\", ax=None,\",\n \"start_date: str / date, optional Input Start Date. For example, time = '03-11-1993'\",\n \"transformed. Parameters ---------- start: int Start of the slicing. step: int Size of\",\n \"can drastically decrease. Returns ------- float quantile (or approximate quantile). See Also --------\",\n \"[str, datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int,\",\n \"], ), (\\\"x\\\", x, [int, float]), ] ) if func not in (\\\"log\\\",\",\n \"See Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based on\",\n \"if offset < 0: offset = max(0, self.parent.shape()[0] - limit) title = \\\"Reads\",\n \"used in the partition. order_by: list, optional List of the vColumns to use\",\n \"lp, rp = \\\"\\\", \\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}'\",\n \"the input number of digits after the comma. Parameters ---------- n: int Number\",\n \"column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER BY\",\n \"- index_start if limit <= 0: limit = 0 limit = \\\" LIMIT\",\n \"self.alias), self.alias, kwargs[\\\"agg\\\"], self.parent.__genSQL__(), self.alias, ) query_result = executeSQL( query=query, title=\\\"Computing the distinct\",\n \"add_history, [bool])]) try: parent = self.parent force_columns = [ column for column in\",\n \"Matplotlib axes object See Also -------- vDataFrame[].bar : Draws the Bar Chart of\",\n \"[self.alias, by] else: columns = [self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from\",\n \"std, MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%',\",\n \"optional Uses the Gaussian distribution to identify outliers. After normalizing the data (Z-Score),\",\n \"in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"]\",\n \"(elem[0] == None) else \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) ) result[idx][1] = \\\"NULL\\\" if (elem[1] ==\",\n \"discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns, cast the\",\n \"the vColumn using 'max' (Maximum). Returns ------- float/str maximum See Also -------- vDataFrame.aggregate\",\n \") # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard\",\n \"if elem[1] != None ] ), ) cmax = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"= ( \\\"(CASE WHEN {} IN ({}) THEN {} || '' ELSE '{}'\",\n \"from verticapy.plot import pie return pie( self, method, of, max_cardinality, h, donut, rose,\",\n \"END odd : CASE ... WHEN vColumn = argv[2 * i] THEN argv[2\",\n \"optional If set to True, NULL values will not be considered during the\",\n \"# Methods # # ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"See Also -------- vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2]\",\n \"self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({}\",\n \"str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the regular\",\n \"is in each of the vColumn records. vDataFrame[].str_count : Computes the number of\",\n \"expr = \\\"CASE WHEN \\\" + \\\" WHEN \\\".join(conditions) + \\\" END\\\" self.apply(func=expr)\",\n \"outliers by the NULL value. winsorize : Clips the vColumn using as lower\",\n \"\\\\ \\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\\",\n \"BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\" ).format(self.alias, max_cardinality\",\n \"expression in each record of the vColumn. The vColumn will be transformed. Parameters\",\n \"|| ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum()\",\n \"h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5, offset: int\",\n \"else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column\",\n \"# Modules # # Standard Python Modules import math, re, decimal, warnings, datetime\",\n \"== \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for i\",\n \"ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query\",\n \"the 3rd. area: bool, optional If set to True, draw an Area Plot.\",\n \"vColumn using 'kurtosis'. Returns ------- float kurtosis See Also -------- vDataFrame.aggregate : Computes\",\n \"vColumn. Parameters ---------- limit: int, optional Number of elements to display. Returns -------\",\n \"histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in\",\n \"{}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result]\",\n \"the vColumn records. vDataFrame[].str_count : Computes the number of matches for the regular\",\n \"the first element (Constant Interpolation). mean : Average. median : median. mode :\",\n \"trans = (\\\"{} || ''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\")\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---#\",\n \"n)) # ---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard\",\n \"nbins <= 0: h = self.numh() else: h = (self.max() - self.min()) *\",\n \"( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {}\",\n \"-threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], ) else: query\",\n \"else \\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"): trans = (\",\n \"the average of the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", )\",\n \"must be numerical to use a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) -\",\n \"**style_kwds) # ---# def boxplot( self, by: str = \\\"\\\", h: float =\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" import verticapy.stats as st\",\n \"otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to train a Random Forest with\",\n \"( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog:\",\n \"topk_percent : kth most occurent element density unique : cardinality (count distinct) var\",\n \"range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime, datetime.date]\",\n \"Aggregates the vColumn using multiple statistical aggregations: min, max, median, unique... depending on\",\n \"by keeping only the input number of digits after the comma. Parameters ----------\",\n \"self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL(\",\n \"6) else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and (val ==\",\n \"element to use to order the data\\\" ) desc = \\\"\\\" if (method\",\n \"\\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0:\",\n \"vColumn elements. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object\",\n \"expected store usage. See Also -------- vDataFrame.expected_store_usage : Returns the vDataFrame expected store\",\n \"return self.transformations[-1][2] # ---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn\",\n \"h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart\",\n \"/ / # ______ / / # \\\\ / / / # \\\\\",\n \"= 0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"specified name. \\\\u26A0 Warning : SQL code generation will be slower if the\",\n \"IS NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE\",\n \"else \\\"AVG\\\" if by == []: if fun == \\\"AVG\\\": val = self.avg()\",\n \"{}.\\\".format( self.alias, dtype ) ) return self.parent except Exception as e: raise ConversionError(\",\n \"sub(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters\",\n \"# # # Modules # # Standard Python Modules import math, re, decimal,\",\n \"dict, optional Method to use to impute the missing values. auto : Mean\",\n \"WHERE {} IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result =\",\n \"median. mode : mode (most occurent element). 0ifnull : 0 when the vColumn\",\n \"{} FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER BY\",\n \"by]) ) if (by) else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc\",\n \"statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"/ # \\\\ / / / # \\\\ / / / # \\\\/\",\n \"check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) #\",\n \"WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where,\",\n \"tuple, optional Tuple including the 2 quantiles used to draw the Plot. start_date:\",\n \"(\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(),\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'avg' (Average). Returns ------- float average See\",\n \"Looks if some specific records are in the vColumn and it returns the\",\n \"all_new_features = [] prefix = ( self.alias.replace('\\\"', \\\"\\\") + prefix_sep.replace('\\\"', \\\"_\\\") if not\",\n \"self.iloc(limit=limit) # ---# def hist( self, method: str = \\\"density\\\", of: str =\",\n \"self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"\\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin\",\n \"elem in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif\",\n \"category when using the 'topk' method. RFmodel_params: dict, optional Dictionary of the Random\",\n \"must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if\",\n \"head of the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit, offset=-1) # ---# def topk(self, k:\",\n \"Also -------- vDataFrame.donut : Draws the donut chart of the vColumn based on\",\n \"Chart of vColumn based on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [str]),\",\n \"Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable from typing\",\n \"affiliates. # Licensed under the Apache License, Version 2.0 (the \\\"License\\\"); # You\",\n \"copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {}\",\n \"Aggregates the vColumn using 'std' (Standard Deviation). Returns ------- float std See Also\",\n \"and max). (x - min) / (max - min) by: list, optional vColumns\",\n \"|_ |~) _ _| _ /~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| #\",\n \"discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the\",\n \"self.alias, self.transformations = ( parent, alias, [elem for elem in transformations], ) self.catalog\",\n \"example, to check if Badr and Fouad are in the vColumn. You can\",\n \"if val == None: warning_message = \\\"The vColumn {} has no mode (only\",\n \"and the values higher than the upper bound to the upper bound itself.\",\n \"Draws the Time Series of the vColumn. Parameters ---------- ts: str TS (Time\",\n \"is null, 1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns\",\n \"data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\"\",\n \"response = self.parent.format_colnames(response) drop(tmp_view_name, method=\\\"view\\\") self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, )\",\n \"of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method,\",\n \"the vColumn using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if\",\n \"{} WHERE {} IS NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias\",\n \"value. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the\",\n \"fun == \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val = self.median()\",\n \"[order_by] check_types( [ ( \\\"method\\\", method, [ \\\"auto\\\", \\\"mode\\\", \\\"0ifnull\\\", \\\"mean\\\", \\\"avg\\\", \\\"median\\\",\",\n \"to name the new categories. If empty, names will be generated. include_lowest: bool,\",\n \"self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1) return best_h # ---# def nunique(self,\",\n \"an aggregation. Parameters ---------- method: str, optional The method to use to aggregate\",\n \"distribution to define the outliers. After normalizing the data (Z-Score), if the absolute\",\n \"= gen_cmap()[0] else: if not (\\\"color\\\" in kwargs): from verticapy.plot import gen_colors kwargs[\\\"color\\\"]\",\n \"ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date, int, float],\",\n \"int): if index_stop < 0: index_stop += self.parent.shape()[0] limit = index_stop - index_start\",\n \"TS field from the vColumn (only if the vColumn type is date like).\",\n \"the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns True if the\",\n \") if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns\",\n \"FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(),\",\n \"Response vColumn. nbins: int, optional Maximum number of nbins used for the discretization\",\n \"iloc(self, limit: int = 5, offset: int = 0): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns a\",\n \"axes. ax: Matplotlib axes object, optional The axes to plot on. **style_kwds Any\",\n \") warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\": if n == 0:\",\n \"check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype = get_data_types( \\\"SELECT {}\",\n \"vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types(\",\n \"datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts)\",\n \"setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s\",\n \"{} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit,\",\n \"\\\"donut\\\" else False rose = True if pie_type == \\\"rose\\\" else False if\",\n \"(\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]),\",\n \"= [self.alias] check = True if len(args) > 0: column = args[0] elif\",\n \"a function to the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\",\",\n \"# ______ / / # \\\\ / / / # \\\\ / /\",\n \"check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format( \\\"{}\\\", to_replace.replace(\\\"'\\\",\",\n \"to an aggregation. vColumns will memorize the already computed aggregations to gain in\",\n \"[self.min()] + result + [self.max()] elif method == \\\"topk\\\": assert k >= 2,\",\n \": number raised to the power of another number round : rounds a\",\n \"vColumn record by an input value. The vColumn will be transformed. Parameters ----------\",\n \"(\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol, [str]),\",\n \"else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end )\",\n \"func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) )\",\n \") query = \\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS\",\n \"str : List of the different transformations. \\\"\\\"\\\" # # Special Methods #\",\n \"abs : absolute value acos : trigonometric inverse cosine asin : trigonometric inverse\",\n \"if not (h) or h <= 0: if nbins <= 0: h =\",\n \"not (prefix) else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if\",\n \"self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q,\",\n \"with 20 trees and a maximum depth of 10. response: str, optional Response\",\n \"self.alias: [top]} ) return top # ---# def mul(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"= \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category in cat:\",\n \"[ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if\",\n \"\\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] ) if\",\n \"vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit, [int,\",\n \"information. Parameters ---------- k: int, optional Number of most occurent elements to return.\",\n \"size to convert to use to convert the vColumn. If this parameter is\",\n \") return self.parent except Exception as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can\",\n \"method: str = \\\"zscore\\\", by: list = [], return_trans: bool = False ):\",\n \"the regular expression is in each of the vColumn records. The vColumn will\",\n \"+= [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"] result.values[\\\"woe\\\"] +=\",\n \"GROUP (ORDER BY {}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY\",\n \"= self.aggregate([\\\"mad\\\", \\\"approx_median\\\"]).values[self.alias] mad *= 1.4826 if mad != 0: if return_trans: return\",\n \"k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv =\",\n \"({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops\",\n \"the input method. Parameters ---------- method: str, optional The describe method. auto :\",\n \"-------- vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name =\",\n \"{} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self, method:\",\n \"optional Labels used to name the new categories. If empty, names will be\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is in each of the vColumn\",\n \"\\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/\",\n \"[], include_lowest: bool = True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes\",\n \"Catalog where each key corresponds to an aggregation. vColumns will memorize the already\",\n \"upper=p_1_alpha) elif method == \\\"null\\\": self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {})\",\n \"result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the\",\n \"---# def mad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation).\",\n \"method != \\\"robust_zscore\\\": max_floor = 0 for elem in by: if len(self.parent[elem].transformations) >\",\n \"p_alpha, self.alias, self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in\",\n \"self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL( query, title=\\\"Different aggregations to\",\n \"conj = \\\"s were \\\" if total > 1 else \\\" was \\\"\",\n \"check_types([(\\\"dtype\\\", dtype, [str])]) try: query = \\\"SELECT {}::{} AS {} FROM {} WHERE\",\n \"query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result\",\n \"# ---# def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies\",\n \"be a cutomized aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn\",\n \"def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined encoding. Parameters\",\n \"category, ctype = \\\"float\\\", \\\"float\\\" elif method == \\\"0ifnull\\\": category, ctype = \\\"int\\\",\",\n \"---# def spider( self, by: str = \\\"\\\", method: str = \\\"density\\\", of:\",\n \"vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the data using the input expression.\",\n \"(\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ] ) assert self.isnum()\",\n \"\\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY\",\n \"Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\",\",\n \"end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts)\",\n \"in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method in [\\\"ffill\\\",\",\n \"limit, [int, float]), (\\\"offset\\\", offset, [int, float])]) if offset < 0: offset =\",\n \"the vColumn Density Plot. Parameters ---------- by: str, optional vColumn to use to\",\n \"will be one of the following: date / int / float / text\",\n \"partition. order_by: list, optional List of the vColumns to use to sort the\",\n \"or ( self.isnum() and method == \\\"smart\\\" ): n = len(result) trans =\",\n \") return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when applying the\",\n \"= method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]),\",\n \"[str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A\",\n \"1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1\",\n \"self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var'\",\n \"- 1], result[i], result[i - 1], result[i] ) trans += \\\" ELSE NULL\",\n \"first dummy to avoid the creation of correlated features. use_numbers_as_suffix: bool, optional Uses\",\n \"vColumn. Returns ------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate\",\n \"self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter( \\\"ABS({} - {}) / {} < {}\\\".format( self.alias, result[\\\"avg\\\"][0], result[\\\"std\\\"][0],\",\n \"trigonometric cotangent exp : exponential function floor : value down to the next\",\n \"title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result): result[idx][0] =\",\n \"a Z-Score - The Standard Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"(numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"), TypeError( \\\"The\",\n \"self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values: for i in range(len(values[elem])): if\",\n \"[ Line2D( [0], [0], color=updated_dict(param, style_kwds, idx)[\\\"color\\\"], lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines,\",\n \"FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset,\",\n \"title=\\\"Testing the Type casting.\\\") self.transformations += [ ( \\\"{}::{}\\\".format(\\\"{}\\\", dtype), dtype, get_category_from_vertica_type(ctype=dtype), )\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float])]) assert x != 0, ValueError(\\\"Division by 0\",\n \"vDataFrame.eval : Evaluates a customized expression. \\\"\\\"\\\" check_types([(\\\"name\\\", name, [str])]) name = quote_ident(name.replace('\\\"',\",\n \"GROUP (ORDER BY {}) OVER () FROM {} LIMIT 1\\\".format( alpha, self.alias, alpha,\",\n \"Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\",\",\n \"dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations += [\",\n \"---# def __setattr__(self, attr, val): self.__dict__[attr] = val # # Methods # #\",\n \"self.__dict__[attr] = val # # Methods # # ---# def aad(self): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"column = args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check =\",\n \") result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\")\",\n \"aggregation (ex: AVG(column1) + 5). ax: Matplotlib axes object, optional The axes to\",\n \"LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\")\",\n \"\\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format(\",\n \"float skewness See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If set to\",\n \"def str_replace(self, to_replace: str, value: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Replaces the regular\",\n \"title=\\\"Computing the optimized histogram nbins using Random Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0]\",\n \"fun = \\\"APPROXIMATE_MEDIAN\\\" query = \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format(\",\n \"= True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with\",\n \"vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"], self.alias: [store_usage]} ) return store_usage #\",\n \"--------------------------------------------------------------------------- Returns a part of the vColumn (delimited by an offset and a\",\n \"0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor\",\n \"\\\"\\\", stddev ), \\\"float\\\", \\\"float\\\", ) ] elif method == \\\"robust_zscore\\\": if n\",\n \"datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ]\",\n \"+= self.parent.shape()[0] limit = index_stop - index_start if limit <= 0: limit =\",\n \"the alias of one of the dummies ({name}).\\\\n\\\" \\\"It can be the result\",\n \"max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias, table ) result = executeSQL(\",\n \"Sum of the vColumn 'of'. q% : q Quantile of the vColumn 'of'\",\n \"greater or equal to 1\\\") where = \\\" WHERE {} IS NOT NULL\",\n \"Forest.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\")\",\n \"return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str = \\\"density\\\", of: str\",\n \"self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\" if\",\n \"BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({})\",\n \"elif n == 1: try: result = executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM\",\n \"h will be picked or computed) h: float, optional Interval width of the\",\n \"using the Robust Z-Score (median and mad). (x - median) / (1.4826 *\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sem\\\"]).values[self.alias][0] # ---# def skewness(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def slice(self, length:\",\n \"the different aggregation. aad : average absolute deviation approx_unique : approximative cardinality count\",\n \"---# def str_slice(self, start: int, step: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The\",\n \"result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0],\",\n \"int = 6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \") result = executeSQL( query=query, title=\\\"Computing the optimized histogram nbins using Random Forest.\\\",\",\n \"[str])]) return self.apply( func=\\\"REGEXP_COUNT({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_extract(self, pat:\",\n \"Uses the threshold instead of the 'alpha' parameter. alpha: float, optional Number representing\",\n \"bins with the same number of elements. same_width : Computes regular width bins.\",\n \"= 1, len(by) if self.isbool(): warning_message = \\\"Normalize doesn't work on booleans\\\".format(self.alias) warnings.warn(warning_message,\",\n \"[bool]), (\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values\",\n \"is in each of the vColumn records. The vColumn will be transformed. Parameters\",\n \"Frequency discretization\\\" ) total, query, nth_elems = nb, [], [] while total <\",\n \"order_by: list, optional List of the vColumns to use to sort the data\",\n \"--------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters ---------- method: str,\",\n \".values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent\",\n \"transformation must be similar to the following: (function, type, category) parent: vDataFrame, optional\",\n \"aggregation (ex: AVG(column1) + 5). of: str, optional The vColumn to use to\",\n \"mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params, [dict]), (\\\"return_enum_trans\\\", return_enum_trans,\",\n \"Parameters ---------- x: float A float between 0 and 1 that represents the\",\n \") # ---# def rename(self, new_name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by\",\n \"* FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes\",\n \"quantiles. Parameters ---------- ts: str TS (Time Series) vColumn to use to order\",\n \"if (h > 1) or (self.category() == \\\"float\\\"): trans = ( \\\"'[' ||\",\n \"self.parent.are_namecols_in([elem for elem in order_by] + by) by = self.parent.format_colnames(by) if method ==\",\n \": Extracts a specific TS field from the vColumn. \\\"\\\"\\\" check_types( [ (\\\"length\\\",\",\n \"method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int\",\n \": Verifies if the regular expression is in each of the vColumn records.\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn using a\",\n \"Also -------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize\",\n \"fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h = max(math.floor(best_h), 1)\",\n \"usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\"\",\n \"== \\\"rose\\\" else False if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import\",\n \"( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result}) for elem in values:\",\n \"date, optional Input End Date. For example, time = '03-11-1993' will filter the\",\n \"new_name.replace('\\\"', \\\"\\\") assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy\",\n \"numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose()\",\n \"!= None else \\\"NULL\\\", ) for elem in result if elem[2] != None\",\n \"vColumn. Parameters ---------- ts: str TS (Time Series) vColumn to use to order\",\n \"plot_median: bool, optional If set to True, the Median will be drawn. ax:\",\n \"is set to 'cat_stats'. Returns ------- tablesample An object containing the result. For\",\n \"tangent tanh : hyperbolic tangent x: int/float, optional If the function has two\",\n \"], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] )\",\n \"method == \\\"0ifnull\\\": category, ctype = \\\"int\\\", \\\"bool\\\" else: category, ctype = self.category(),\",\n \"\\\"({} - {}) / {}({})\\\".format( \\\"{}\\\", avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", stddev\",\n \"def normalize( self, method: str = \\\"zscore\\\", by: list = [], return_trans: bool\",\n \"query=query, title=\\\"Computing the average of the {}'s lower and upper outliers.\\\".format( self.alias ),\",\n \"\\\"Describes the statics of {} partitioned by {}.\\\".format( numcol, self.alias ) values =\",\n \"Also -------- vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using\",\n \"{})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation\",\n \"DECADE / DOQ / DOW / DOY / EPOCH / HOUR / ISODOW\",\n \"/ MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH / QUARTER /\",\n \") except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor):\",\n \"/ / / # \\\\_______/ / / # ______ / / # \\\\\",\n \"int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the vDataFrame\",\n \"for the regular expression in each record of the vColumn. vDataFrame[].extract : Extracts\",\n \"vDataFrame[].extract : Extracts the regular expression in each record of the vColumn. vDataFrame[].str_replace\",\n \"0ifnull : 0 when the vColumn is null, 1 otherwise. expr: str, optional\",\n \"0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0:\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns -------\",\n \"+= [(func, ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed\",\n \"FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT\",\n \"object containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].head\",\n \"Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if it is used\",\n \"h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"[int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for item in result], }\",\n \"computation. cat_stats : Computes statistics of a numerical column for each vColumn category.\",\n \"optional Returns the transformation instead of the vDataFrame parent and do not apply\",\n \"UNION ALL \\\".join(query), nbins - 1 ) result = executeSQL( query=query, title=\\\"Computing the\",\n \"start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median:\",\n \"{} IN ({}) THEN {} || '' ELSE '{}' END)\\\".format( bin_spatial_to_str(self.category()), \\\", \\\".join(\",\n \"or equals to 2 in case of discretization using the method 'smart'.\\\" )\",\n \"the vColumn. abs : absolute value acos : trigonometric inverse cosine asin :\",\n \"self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def add_copy(self, name: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds\",\n \"AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {} < {})\",\n \"self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\", self.alias) query = \\\"SELECT {}\",\n \"numerical (except ints and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20,\",\n \"as e: raise QueryError( \\\"{}\\\\nError when applying the func 'x -> {}' to\",\n \"self.isnum() and method == \\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema =\",\n \"8, \\\"nbins\\\": 100}) model.set_params(RFmodel_params) parameters = model.get_params() try: model.fit(tmp_view_name, [self.alias], response) query =\",\n \"] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha == None: mean_alpha\",\n \"kernel, [\\\"gaussian\\\", \\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]),\",\n \"check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\", upper, [float, int])]) assert (lower != None) or\",\n \"compute other vColumns. Parameters ---------- add_history: bool, optional If set to True, the\",\n \"func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to\",\n \"Returns ------- list Distinct caterogies of the vColumn. See Also -------- vDataFrame.topk :\",\n \"vDataFrame memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) +\",\n \"of the ceiling. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts\",\n \"sigmoid : Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number\",\n \"information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib axes object \\\"\\\"\\\" columns =\",\n \"box plot. The other categories will be filtered. ax: Matplotlib axes object, optional\",\n \"non_events = 0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events)))\",\n \"the vDataFrame memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias)\",\n \"\\\"zscore\\\": if n == 0: nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias]\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the vColumn. Parameters ---------- func: str\",\n \"nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str = \\\"\\\",\",\n \"datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"] ) self.parent.are_namecols_in(ts) ts = self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self,\",\n \"are in the vColumn and it returns the new vDataFrame of the search.\",\n \"float std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"than the threshold, it will be considered as an outlier. use_threshold: bool, optional\",\n \"sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100 * sauv[\\\"count\\\"] / self.parent.shape()[0] ) except: pass self.parent.__add_to_history__(\",\n \"executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False, ) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent,\",\n \"def nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn\",\n \"be empty in case of discretization using the method 'smart'.\\\" ) self.parent.are_namecols_in(response) response\",\n \"query, ) title = \\\"Computing WOE & IV of {} (response = {}).\\\".format(self.alias,\",\n \"ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM / MILLISECONDS / MINUTE / MONTH\",\n \"like. Optimized h will be computed if the parameter is empty or invalid.\",\n \"(method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table\",\n \"instead of the vDataFrame parent and do not apply it. This parameter is\",\n \"method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]),\",\n \"the vColumn. vDataFrame[].tail : Returns the tail of the vColumn. \\\"\\\"\\\" check_types([(\\\"limit\\\", limit,\",\n \"the values higher than the upper bound to the upper bound itself. Parameters\",\n \"the vColumn. The category will be one of the following: date / int\",\n \"method in (\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif\",\n \"50% for the median) prod : product range : difference between the max\",\n \"-------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]),\",\n \"\\\"numh is only available on type numeric|date\\\" ) if self.isnum(): result = (\",\n \"rule. Parameters ---------- val: int/float/str, optional Value to use to impute the vColumn.\",\n \"\\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some\",\n \"[int, float])]) if n == 1: pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"top\\\") if pre_comp !=\",\n \"learning and scoring phases. xlim: tuple, optional Set the x limits of the\",\n \") else: query = \\\"SELECT PERCENTILE_CONT({}) WITHIN GROUP (ORDER BY {}) OVER (),\",\n \"{}, AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0],\",\n \"type. Parameters ---------- dtype: str New type. Returns ------- vDataFrame self.parent See Also\",\n \"cmin, ) else: final_transformation = [ ( \\\"({} - {}) / {}({} -\",\n \"isinstance(val, str): val = val.replace(\\\"'\\\", \\\"''\\\") if val != None: new_column = \\\"COALESCE({},\",\n \"== [0, 1], TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) )\",\n \"self.apply(func=\\\"{} / ({})\\\".format(\\\"{}\\\", x)) # ---# def drop(self, add_history: bool = True): \\\"\\\"\\\"\",\n \"h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot\",\n \"self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} smallest elements.\\\".format(n, self.alias)\",\n \"prefix: str, optional Prefix of the dummies. prefix_sep: str, optional Prefix delimitor of\",\n \"float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x:\",\n \"\\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return self.parent # ---# def distinct(self,\",\n \": hyperbolic tangent x: int/float, optional If the function has two arguments (example,\",\n \"‘pipeline’ mechanism to sequentialize # data transformation operations, and offers beautiful graphical options.\",\n \"if (is_date) and not (method == \\\"categorical\\\"): result = self.aggregate([\\\"count\\\", \\\"min\\\", \\\"max\\\"]) index\",\n \"= self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"]\",\n \"title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] +\",\n \"quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is set to False else\",\n \"from typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import *\",\n \"vColumn is missing. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.filter: Filters the\",\n \"in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except\",\n \"the parent vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame\",\n \"optional Set the x limits of the current axes. ax: Matplotlib axes object,\",\n \"BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the vColumn based on an aggregation.\",\n \"statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if\",\n \"to replace. value: str, optional New value. Returns ------- vDataFrame self.parent See Also\",\n \"the approximate median is returned. By setting this parameter to False, the function's\",\n \"ParameterError( \\\"numh is only available on type numeric|date\\\" ) if self.isnum(): result =\",\n \"except: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\",\",\n \"* from verticapy.errors import * ## # # __ __ ______ ______ __\",\n \"\\\"\\\"\\\" # # Special Methods # # ---# def __init__( self, alias: str,\",\n \"rp = \\\"(\\\", \\\")\\\" else: lp, rp = \\\"\\\", \\\"\\\" for category in\",\n \"trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else \\\"topk\\\", nbins=nbins, k=nbins, new_category=\\\"Others\\\", return_enum_trans=True, )[0].replace(\\\"{}\\\",\",\n \"1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND {})\\\".format(self.alias,\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].describe : Computes the vColumn descriptive\",\n \")[self.alias].density( bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=(xmin, xmax), ax=ax, **updated_dict(param, style_kwds, idx), ) custom_lines +=\",\n \"[int, float]), (\\\"pie_type\\\", pie_type, [\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if\",\n \"If the function has two arguments (example, power or mod), 'x' represents the\",\n \"ZScores. threshold: float, optional Uses the Gaussian distribution to define the outliers. After\",\n \"bool = True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn\",\n \"100 * COUNT(*) / {} AS percent FROM {}{} GROUP BY {} ORDER\",\n \"mode) topk_percent : kth most occurent element density unique : cardinality (count distinct)\",\n \"= self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(),\",\n \"vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by =\",\n \"float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\", method, [\\\"sturges\\\", \\\"freedman_diaconis\\\", \\\"fd\\\", \\\"auto\\\"])] )\",\n \"Parameters ---------- field: str The field to extract. It must be one of\",\n \"limit = \\\" LIMIT {}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {}\",\n \": average median : median min : minimum mode : most occurent element\",\n \"check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]),\",\n \"following: (function, type, category) parent: vDataFrame, optional Parent of the vColumn. One vDataFrame\",\n \"cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt :\",\n \"mean : Replaces the upper and lower outliers by their respective average. null\",\n \"order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in order_by]) new_column = \\\"COALESCE({},\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\",\",\n \"optional Tuple including the 2 quantiles used to draw the Plot. start_date: str\",\n \"if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for elem in copy_trans] for\",\n \"IV of {} (response = {}).\\\".format(self.alias, y) result = to_tablesample(query, title=title) result.values[\\\"index\\\"] +=\",\n \"matches for the regular expression in each record of the vColumn. vDataFrame[].extract :\",\n \"Sigmoid kernel. silverman : Silverman kernel. nbins: int, optional Maximum number of points\",\n \"Input Start Date. For example, time = '03-11-1993' will filter the data when\",\n \"MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif n\",\n \"(start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end\",\n \"be picked or computed) nbins: int, optional Number of nbins. If empty, an\",\n \"None): val = self.mode(dropna=True) if val == None: warning_message = \\\"The vColumn {}\",\n \"nb != 0, Exception( \\\"Not enough values to compute the Equal Frequency discretization\\\"\",\n \"Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\")\",\n \"str, optional vColumn to use to partition the TS. start_date: str / date,\",\n \"max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float, tuple] = (None, None),\",\n \"in sauv: self.catalog[\\\"count\\\"] = int(sauv[\\\"count\\\"]) + total self.catalog[\\\"percent\\\"] = ( 100 * (int(sauv[\\\"count\\\"])\",\n \"self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter( \\\"({} BETWEEN {} AND\",\n \"\\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol) assert self.parent[numcol].category() in (\\\"float\\\", \\\"int\\\"),\",\n \": Back Propagation of the next element (Constant Interpolation). ffill : Propagation of\",\n \"n: int Number of digits to keep after the comma. Returns ------- vDataFrame\",\n \"self.catalog[elem] = (sauv[elem] - sauv[\\\"mean\\\"]) / sauv[ \\\"std\\\" ] elif method == \\\"minmax\\\":\",\n \"\\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError( \\\"numh\",\n \"and scoring phases. xlim: tuple, optional Set the x limits of the current\",\n \"the vColumn by the input element. Parameters ---------- x: float Input number. Returns\",\n \"> 0.0001: h = round(h, 4) elif h > 0.000001: h = round(h,\",\n \"bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn\",\n \"Deviation is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif (n ==\",\n \"timestamp...) or numerical. q: tuple, optional Tuple including the 2 quantiles used to\",\n \"self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed using a mean\",\n \"the vDataFrame. \\\"\\\"\\\" if isinstance(val, str) or not (isinstance(val, Iterable)): val = [val]\",\n \"100 * COUNT({1}) / {2} AS percent, AVG({3}{4}) AS mean, STDDEV({3}{4}) AS std,\",\n \"vDataFrame[].ctype : Returns the vColumn database type. \\\"\\\"\\\" return self.transformations[-1][2] # ---# def\",\n \"range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY\",\n \"result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i]\",\n \"'nbins' must be greater or equals to 2 in case of discretization using\",\n \"(cardinality). Parameters ---------- approx: bool, optional If set to True, the approximate cardinality\",\n \"to False, the function's performance can drastically decrease. Returns ------- float/str median See\",\n \"def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns ------- float/str\",\n \"0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from verticapy.learn.neighbors import KernelDensity schema\",\n \"be one of the following: date / int / float / text /\",\n \"else \\\"\\\" ) order_by_ts = \\\", \\\".join([quote_ident(column) + desc for column in order_by])\",\n \"{} AND {})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\"\",\n \"# ---# def mul(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Multiplies the vColumn by the\",\n \"the vColumn. \\\"\\\"\\\" return self.iloc(limit=limit) # ---# def hist( self, method: str =\",\n \"usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) +\",\n \"response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]),\",\n \"on data stored in Vertica, taking advantage Vertica’s # speed and built-in analytics\",\n \": Computes statistics of a numerical column for each vColumn category. In this\",\n \"ord, SUM(1 - {}) AS non_events, SUM({}) AS events FROM ({}) x GROUP\",\n \"on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\",\",\n \"--------------------------------------------------------------------------- Replaces the regular expression matches in each of the vColumn record by\",\n \"max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] )\",\n \"None else \\\"NULL\\\", ) for elem in result if elem[1] != None ]\",\n \"\\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self):\",\n \"# ---# def drop(self, add_history: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn\",\n \"frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] elif\",\n \"(\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]), (\\\"right\\\", right, [bool]), ]\",\n \"---------- field: str The field to extract. It must be one of the\",\n \"\\\"'{}', {}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr =\",\n \"op1, op2, close_l, close_r = \\\"<=\\\", \\\"<\\\", \\\"[\\\", \\\"[\\\" if idx == 0\",\n \"cos : trigonometric cosine cosh : hyperbolic cosine cot : trigonometric cotangent exp\",\n \"--------------------------------------------------------------------------- Returns the category of the vColumn. The category will be one of\",\n \"self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\", x)) # ---# def sum(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"trans += \\\" ELSE NULL END)\\\" trans = (trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans:\",\n \"the data. count : Number of elements. density : Percentage of the distribution.\",\n \"def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float\",\n \"\\\".join(by) ), \\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if\",\n \"part of the DB version you are using. Returns ------- tablesample An object\",\n \"optional vColumn to use to partition the data. bandwidth: float, optional The bandwidth\",\n \"decimal.Decimal): top = float(top) self.parent.__update_catalog__( {\\\"index\\\": [\\\"top{}\\\".format(n)], self.alias: [top]} ) return top #\",\n \"(\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int, float]), ] )\",\n \"* i + 1] ... ELSE argv[n] END Returns ------- vDataFrame self.parent See\",\n \"'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not be empty in case\",\n \"time = '03-11-1993' will filter the data when 'ts' is lesser than November\",\n \"vColumn_075, vColumn_max = result sturges = max( float(vColumn_max - vColumn_min) / int(math.floor(math.log(count, 2)\",\n \"\\\"smart\\\": schema = verticapy.options[\\\"temp_schema\\\"] if not (schema): schema = \\\"public\\\" tmp_view_name = gen_tmp_name(schema=schema,\",\n \"|(_(_|| \\\\/ # / # VerticaPy is a Python library with scikit-like functionality\",\n \"of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6), h: Union[int, float,\",\n \"preparing your data. Parameters ---------- new_name: str The new vColumn alias. Returns -------\",\n \"if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and method == \\\"smart\\\"\",\n \"Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]),\",\n \"to be used as categorical (No h will be picked or computed) ax:\",\n \"/ NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events =\",\n \"{})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return \\\"({} - {}) /\",\n \"0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except: ctype = get_data_types( \\\"SELECT\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype, category)] self.parent.__update_catalog__(erase=True,\",\n \"\\\"_\\\", drop_first: bool = True, use_numbers_as_suffix: bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes\",\n \"def range_plot( self, ts: str, q: tuple = (0.25, 0.75), start_date: Union[str, datetime.datetime,\",\n \"of the different categories to consider when drawing the box plot. The other\",\n \": minimum mode : most occurent element percent : percent of non-missing elements\",\n \"- {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message =\",\n \"------- bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool :\",\n \"+ nth_elems + [str(count)]) ) query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER()\",\n \"== \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] )\",\n \"cardinality (count distinct) var : variance Other aggregations could work if it is\",\n \") ) else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent\",\n \"(trans, \\\"varchar\\\", \\\"text\\\") if return_enum_trans: return trans else: self.transformations += [trans] sauv =\",\n \"using 'median'. Parameters ---------- approx: bool, optional If set to True, the approximate\",\n \"multiple times, so it's better practice to use this method when first preparing\",\n \"number of seconds, otherwise it will represent a number. Returns ------- vDataFrame self.parent\",\n \"(\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by)\",\n \"geopandas plot function. For more information, see: https://geopandas.readthedocs.io/en/latest/docs/reference/api/ geopandas.GeoDataFrame.plot.html Returns ------- ax Matplotlib\",\n \"vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the\",\n \"if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by = ( \\\"PARTITION BY\",\n \"True, the approximate quantile is returned. By setting this parameter to False, the\",\n \"to True, the information will be stored in the vDataFrame history. Returns -------\",\n \": Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product #\",\n \"if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else: return self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method:\",\n \"isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by,\",\n \"closed. If set to True, the intervals will be closed on the right.\",\n \"a user-defined encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn\",\n \"column in enumerate(columns): param = {\\\"color\\\": colors[idx % len(colors)]} ax = self.parent.search( \\\"{}\",\n \"# ---# def round(self, n: int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping\",\n \"Also -------- vDataFrame[].slice : Slices the vColumn using a time series rule. \\\"\\\"\\\"\",\n \"catalog: self.catalog[elem] = catalog[elem] # ---# def __getitem__(self, index): if isinstance(index, slice): assert\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Adds the input element to the vColumn. Parameters ---------- x: float\",\n \"str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date]\",\n \"input method. Parameters ---------- method: str, optional The method to use to discretize\",\n \"vDataFrame : Parent of the vColumn. transformations, str : List of the different\",\n \"/ /\\\\ ___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./\",\n \"index_start if limit <= 0: limit = 0 limit = \\\" LIMIT {}\\\".format(limit)\",\n \"vColumn distinct elements to be used as categorical. The less frequent elements will\",\n \"for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv\",\n \"\\\" was \\\" if verticapy.options[\\\"print_info\\\"]: print(\\\"{} element{}filled.\\\".format(total, conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing\",\n \"\\\"percent\\\": 100.0, \\\"unique\\\": 2, \\\"approx_unique\\\": 2, \\\"prod\\\": 0, }, ) setattr(self.parent, name, new_vColumn)\",\n \"---------- method: str, optional Method to use to compute the optimal h. auto\",\n \"Applies a default function to the vColumn. Parameters ---------- func: str Function to\",\n \"be transformed. Parameters ---------- start: int Start of the slicing. step: int Size\",\n \"'avg' (Average). Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the\",\n \"float, optional The interval size to convert to use to convert the vColumn.\",\n \"FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query = \\\"SELECT {},\",\n \"query = \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS\",\n \"partition. return_trans: bool, optimal If set to True, the method will return the\",\n \"skew = skewness # ---# def slice(self, length: int, unit: str = \\\"second\\\",\",\n \"{} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {}\",\n \"missing values. auto : Mean for the numerical and Mode for the categorical\",\n \"of using previously the method on the vColumn \\\" \\\"or simply because of\",\n \"\\\\ \\\\____ \\\\ \\\\ \\\\_\\\\ \\\\ \\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-.\",\n \"-------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].get_dummies : Encodes\",\n \"return ts_plot( self, ts, by, start_date, end_date, area, step, ax=ax, **style_kwds, ) #\",\n \"end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts)\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\",\",\n \"[self.alias] if of: self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import spider as spider_plot\",\n \"density unique : cardinality (count distinct) var : variance Other aggregations could work\",\n \"\\\"Parameter 'response' can not be empty in case of discretization using the method\",\n \"{}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax,\",\n \"transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) )\",\n \"dummies. prefix_sep: str, optional Prefix delimitor of the dummies. drop_first: bool, optional Drops\",\n \"the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding.\",\n \"# ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is boolean,\",\n \"0 OR events = 0 THEN 0 ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS\",\n \"= ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025,\",\n \"(method == \\\"categorical\\\")) or ( method == \\\"is_numeric\\\" ): self.parent.__update_catalog__({\\\"index\\\": index, self.alias: result})\",\n \"self.catalog[elem] = sauv[elem] return self.parent # ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"------- int number of non-Missing elements. See Also -------- vDataFrame.aggregate : Computes the\",\n \"self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else:\",\n \"method. Parameters ---------- method: str, optional Method to use to normalize. zscore :\",\n \"MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ),\",\n \"* ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS iv FROM ({}) x ORDER BY ord\\\".format(\",\n \"False else the lower and upper ZScores. threshold: float, optional Uses the Gaussian\",\n \"auto : Uses method 'same_width' for numerical vColumns, cast the other types to\",\n \"if the regular expression is in each of the vColumn records. The vColumn\",\n \"self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp assert self.isnum() or self.isdate(), ParameterError(\",\n \"Draws the Box Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or\",\n \"self.alias, self.parent.__genSQL__(), self.alias, self.alias, self.alias, ) else: query = \\\"SELECT {} FROM (SELECT\",\n \"the n smallest elements in the vColumn. Parameters ---------- n: int, optional Offset.\",\n \"FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(), self.alias, self.alias, p_alpha, self.alias, self.alias, p_1_alpha,\",\n \"AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent FROM\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int, optional\",\n \"= 200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the\",\n \"vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns the vDataFrame memory\",\n \"method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool = True, alpha:\",\n \"= False if check: self.parent.are_namecols_in(column) column = self.parent.format_colnames(column) columns += [column] if not\",\n \"the mode) topk_percent : kth most occurent element density unique : cardinality (count\",\n \"--------------------------------------------------------------------------- Encodes the vColumn using a bijection from the different categories to [0,\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"dropna\\\", dropna, [bool]), (\\\"n\\\", n, [int, float])]) if\",\n \"(\\\"h\\\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by)\",\n \"str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a default function to the\",\n \"\\\" END\\\" self.apply(func=expr) # ---# def ctype(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the vColumn DB\",\n \"ax Matplotlib axes object See Also -------- vDataFrame.bar : Draws the Bar Chart\",\n \"= \\\"NULL\\\" if mean_1_alpha == None: mean_alpha = \\\"NULL\\\" self.apply( func=\\\"(CASE WHEN {}\",\n \"if not (schema): schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple,\",\n \"[list]), (\\\"h\\\", h, [list, float, int]), ] ) if by: self.parent.are_namecols_in(by) by =\",\n \"self.apply(func=\\\"{} * ({})\\\".format(\\\"{}\\\", x)) # ---# def nlargest(self, n: int = 10): \\\"\\\"\\\"\",\n \"if elem[1] != None ] ), ) stddev = \\\"DECODE({}, {}, NULL)\\\".format( by[0],\",\n \"Increasing this parameter will increase the precision but will also increase the time\",\n \"= abs(self.count() - total) except Exception as e: self.transformations = [elem for elem\",\n \": 'Others'. cat_priority: list, optional List of the different categories to consider when\",\n \"using the method 'same_freq'\\\" ) count = self.count() nb = int(float(count / int(nbins)))\",\n \"END AS woe, CASE WHEN non_events = 0 OR events = 0 THEN\",\n \"pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query,\",\n \"self.alias, self.alias, n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return\",\n \"normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] == None: pass elif\",\n \"the vColumn (delimited by an offset and a limit). Parameters ---------- limit: int,\",\n \"spider plot of the input vColumn based on an aggregation. Parameters ---------- by:\",\n \"{}) VERTICAPY_OPTIMAL_H_TABLE\\\".format( min_date, self.alias, self.alias, self.parent.__genSQL__() ) query = \\\"SELECT COUNT({}) AS NAs,\",\n \"= \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result\",\n \"------- ax Matplotlib axes object \\\"\\\"\\\" columns = [self.alias] check = True if\",\n \"a mean encoding with {} as Response Column.\\\".format( self.alias, response ) ) if\",\n \"\\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp store_usage =\",\n \"/ # _____________ / / # \\\\ / / / # \\\\ /\",\n \"str, optional Slice size unit. For example, it can be 'minute' 'hour'... start:\",\n \": trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the function\",\n \"{})\\\".format(self.alias, p_alpha, p_1_alpha) ) return self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters\",\n \"'topk' method. RFmodel_params: dict, optional Dictionary of the Random Forest model parameters used\",\n \"import gen_colors kwargs[\\\"color\\\"] = gen_colors()[0] if not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True\",\n \"use this method when first preparing your data. Parameters ---------- new_name: str The\",\n \"ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the box plot of the vColumn. Parameters\",\n \"= sauv[elem] elif elem == None: self.catalog[elem] = None elif method == \\\"robust_zscore\\\":\",\n \"Encoding. vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].label_encode : Encodes the\",\n \"(standard error of mean). Returns ------- float sem See Also -------- vDataFrame.aggregate :\",\n \"mean encoding with {} as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]:\",\n \"{} OFFSET {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, )\",\n \"pie( self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---#\",\n \"= executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY\",\n \"method.lower() check_types( [ (\\\"method\\\", method, [\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\",\",\n \"int(self.count()) # ---# def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self):\",\n \"Replaces the upper and lower outliers by their respective average. null : Replaces\",\n \"with 0 and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method\",\n \"entire relation, a vColumn can be seen as one column of that relation.\",\n \"0.75) AS 'approx_75%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4})\",\n \"minimum mode : most occurent element percent : percent of non-missing elements q%\",\n \"0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"])._repr_html_()\",\n \"count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT *\",\n \"warning_message = \\\"The method 'robust_zscore' is available only if the parameter 'by' is\",\n \"\\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\":\",\n \"max(0, self.parent.shape()[0] - limit) title = \\\"Reads {}.\\\".format(self.alias) tail = to_tablesample( \\\"SELECT {}\",\n \": Regular pie chart. donut : Donut chart. rose : Rose chart. It\",\n \"({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message = \\\"Can not normalize\",\n \"vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def isdate(self):\",\n \"drawing the box plot. The other categories will be filtered. ax: Matplotlib axes\",\n \"vDataFrame.memory_usage : Returns the vDataFrame memory usage. \\\"\\\"\\\" import sys total = (\",\n \"verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds,\",\n \"optional List of the different transformations. Each transformation must be similar to the\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"aad\\\"]).values[self.alias][0] # ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the\",\n \"max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int = 5,\",\n \"\\\"\\\", stddev ) else: final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format(\",\n \"lower bound to the lower bound itself and the values higher than the\",\n \"= \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str):\",\n \"normalize {} using a Robust Z-Score - The MAD is null !\\\".format( self.alias\",\n \"{}) (SELECT AVG({}) FROM vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({})\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew =\",\n \"\\\"logistic\\\", \\\"sigmoid\\\", \\\"silverman\\\"]), (\\\"bandwidth\\\", bandwidth, [int, float]), (\\\"nbins\\\", nbins, [float, int]), ] )\",\n \"OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL)\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'skewness'. Returns ------- float skewness See Also\",\n \"can only have one parent. catalog: dict, optional Catalog where each key corresponds\",\n \"maximum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"= '{}', tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i\",\n \"len(breaks) == len(labels) + 1 or not (labels), ParameterError( \\\"Length of parameter breaks\",\n \"kwargs[\\\"figsize\\\"] = (14, 10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix:\",\n \"datetime.datetime, datetime.date, int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float],\",\n \"self.alias, query, ) title = \\\"Computing WOE & IV of {} (response =\",\n \"License. # You may obtain a copy of the License at # #\",\n \"self.parent.__genSQL__(), by[0] ) result = executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", )\",\n \"= max( len(self.parent[column].transformations), max_floor ) except: pass max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name)\",\n \"result[idx][1] = \\\"NULL\\\" if (elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({},\",\n \"Median will be drawn. ax: Matplotlib axes object, optional The axes to plot\",\n \"in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent # ---#\",\n \"a mean encoding\\\" ) max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k\",\n \"Name of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval :\",\n \"x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Subtracts the input element from the vColumn. Parameters ----------\",\n \"kurtosis : kurtosis jb : Jarque-Bera index mad : median absolute deviation max\",\n \"final generated SQL code. Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\"\",\n \"h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of\",\n \"{}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem] = catalog[elem] # ---#\",\n \"== 0: warning_message = \\\"Can not normalize {} using a Z-Score - The\",\n \"vDataFrame parent and do not apply it. This parameter is very useful for\",\n \"bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] elif self.isnum() and\",\n \"str TS (Time Series) vColumn to use to order the data. The vColumn\",\n \"of the vColumn (delimited by an offset and a limit). Parameters ---------- limit:\",\n \"sign : arithmetic sign sin : trigonometric sine sinh : hyperbolic sine sqrt\",\n \"vDataFrame. This parameter is used for testing purpose. Returns ------- vDataFrame self.parent See\",\n \"h: int/float/tuple, optional Interval width of the vColumns 1 and 2 bars. It\",\n \"was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), )\",\n \"> 6) else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and (val\",\n \"computation. Returns ------- tablesample An object containing the result. For more information, see\",\n \"first element (Constant Interpolation). mean : Average. median : median. mode : mode\",\n \"--------------------------------------------------------------------------- Fills missing elements in the vColumn with a user-specified rule. Parameters ----------\",\n \"vColumn to the parent vDataFrame. Parameters ---------- name: str Name of the copy.\",\n \"of an independent variable in relation to the dependent variable. Parameters ---------- y:\",\n \"3)) for item in result], } return tablesample(values) # ---# def value_counts(self, k:\",\n \"Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage : Returns\",\n \"y, query, ) query = \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events)\",\n \"The method used for the plot. gaussian : Gaussian kernel. logistic : Logistic\",\n \"[ (\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]),\",\n \"optional Interval width if the vColumn is numerical or of type date like.\",\n \"# ---# def abs(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies the absolute value function to the\",\n \"str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each record of\",\n \"(Number of non-Missing elements). Returns ------- int number of non-Missing elements. See Also\",\n \"Also -------- vDataFrame[].describe : Computes the vColumn descriptive statistics. \\\"\\\"\\\" return self.describe(method=\\\"categorical\\\", max_cardinality=k)\",\n \"BY _verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, )\",\n \"Encodes the vColumn with the One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional\",\n \"transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {},\",\n \": hyperbolic cosine cot : trigonometric cotangent exp : exponential function floor :\",\n \"self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is only available for categorical\",\n \"of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def iloc(self, limit: int =\",\n \"cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ]\",\n \"* mad) minmax : Normalization using the MinMax (min and max). (x -\",\n \"op2, close_l, close_r = \\\"<\\\", \\\"<=\\\", \\\"]\\\", \\\"]\\\" else: op1, op2, close_l, close_r\",\n \"elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label =\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.quantile(0.5,\",\n \"50): try: result = executeSQL( \\\"SELECT {}, AVG({}), STDDEV({}) FROM {} GROUP BY\",\n \"values lesser than the lower bound to the lower bound itself and the\",\n \"query = \\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY\",\n \"by = [by] check_types( [ (\\\"method\\\", method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]),\",\n \"offset: int, optional Number of elements to skip. Returns ------- tablesample An object\",\n \"self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical\",\n \": Clips the vColumn using as lower bound quantile(alpha) and as upper bound\",\n \"FROM vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\"\",\n \"where, self.alias, n ), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if\",\n \"the vColumn. labels: list, optional Labels used to name the new categories. If\",\n \"Encodes the vColumn with One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response =\",\n \"be included. right: bool, optional How the intervals should be closed. If set\",\n \"end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step: bool =\",\n \"[trans] sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias])\",\n \"\\\" \\\"or simply because of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the\",\n \"by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0] ), method=\\\"fetchall\\\", )\",\n \"= 0 OR events = 0 THEN 0 ELSE (pt_non_events - pt_events) *\",\n \"'name', you'll be able to solve this issue.\\\" ) new_vColumn = vColumn( name,\",\n \"not in kwargs: query = \\\"SELECT {} AS {} FROM {} WHERE {}\",\n \"smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT\",\n \"by: str, optional vColumn to use to partition the data. h: float, optional\",\n \"True if the vColumn category is date. \\\"\\\"\\\" return self.category() in (\\\"float\\\", \\\"int\\\")\",\n \"result of using previously the method on the vColumn \\\" \\\"or simply because\",\n \": Normalization using the Robust Z-Score (median and mad). (x - median) /\",\n \"---# def str_contains(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Verifies if the regular expression is\",\n \"= [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", )\",\n \"a response. \\\"\\\"\\\" if self.category() in [\\\"date\\\", \\\"float\\\"]: warning_message = ( \\\"label_encode is\",\n \"optional Value to use to impute the vColumn. method: dict, optional Method to\",\n \"quantile(1-alpha) will be dropped. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers :\",\n \"return spider_plot( self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---#\",\n \"series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\", start_date,\",\n \"response. \\\"\\\"\\\" import verticapy.stats as st return self.apply(func=st.decode(str_sql(\\\"{}\\\"), *argv)) # ---# def density(\",\n \"int): \\\"\\\"\\\" --------------------------------------------------------------------------- Rounds the vColumn by keeping only the input number of\",\n \"inverse cosine asin : trigonometric inverse sine atan : trigonometric inverse tangent cbrt\",\n \"equal to 2.\\\" ) assert len(breaks) == len(labels) + 1 or not (labels),\",\n \"lw=4, ), ] ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], )\",\n \"The other categories will be filtered. ax: Matplotlib axes object, optional The axes\",\n \"# \\\\ / # \\\\ / # \\\\/ # _ # \\\\ /\",\n \"Uses the Random Forest on a response column to find the most relevant\",\n \"-------- vDataFrame[].head : Returns the head of the vColumn. vDataFrame[].tail : Returns the\",\n \"str The new vColumn alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy\",\n \"collections.abc import Iterable from typing import Union # VerticaPy Modules import verticapy from\",\n \"= \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS count, 100 * COUNT({1}) / {2}\",\n \"+ [item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0] for\",\n \"self.catalog[\\\"mad\\\"] = 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"]\",\n \"False otherwise. Returns ------- bool True if the vColumn is boolean. See Also\",\n \"= max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category() == \\\"int\\\": best_h =\",\n \"matches in each of the vColumn records by an input value. vDataFrame[].str_slice :\",\n \"if the regular expression is in each of the vColumn records. vDataFrame[].str_count :\",\n \"self.ctype()] + result, } if ((is_date) and not (method == \\\"categorical\\\")) or (\",\n \"added to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---# def\",\n \"can be the result of using previously the method on the vColumn \\\"\",\n \"order_by] for elem in all_partition: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor\",\n \"range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)]\",\n \"\\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj, ) ) else: if\",\n \"split_value FROM (SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL\",\n \"self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if (method == \\\"mode\\\") and\",\n \"FROM {} LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin\",\n \"bar chart of the vColumn based on an aggregation. Parameters ---------- method: str,\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types( [ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]),\",\n \"(\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [list]), (\\\"h\\\", h, [list, float, int]), ] )\",\n \"item in result], \\\"count\\\": [int(item[1]) for item in result], \\\"percent\\\": [float(round(item[2], 3)) for\",\n \"drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model = RandomForestClassifier(tmp_model_name)\",\n \"[str])]) try: try: ctype = get_data_types( \\\"SELECT {} AS apply_test_feature FROM {} WHERE\",\n \"expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower()\",\n \"the vColumn records by an input value. \\\"\\\"\\\" check_types([(\\\"start\\\", start, [int, float]), (\\\"step\\\",\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[2] if elem[2] != None\",\n \"(len(by) == 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun\",\n \"check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def sem(self): \\\"\\\"\\\"\",\n \"self.alias, self.alias, self.parent.__genSQL__(), by[0], ), title=\\\"Computing the different categories {} to normalize.\\\".format( by[0]\",\n \"WHEN {} < {} THEN {} WHEN {} > {} THEN {} ELSE\",\n \"0 self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the\",\n \"mean skewness : skewness sum : sum std : standard deviation topk :\",\n \"bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try: result = model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds\",\n \"= [\\\"DECODE({}\\\"] text_info = \\\"\\\\n\\\" for k in range(len(distinct_elements)): expr += [ \\\"'{}',\",\n \"the {}'s lower and upper outliers.\\\".format( self.alias ), method=\\\"fetchall\\\", ) ] if mean_alpha\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Applies a function to the vColumn. Parameters ---------- func: str, Function\",\n \"'median'. Parameters ---------- approx: bool, optional If set to True, the approximate median\",\n \"used instead of the parent vDataFrame. This parameter is used for testing purpose.\",\n \"method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6,\",\n \"bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\",\",\n \"def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn is missing. Returns\",\n \"self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot( self, ts, by, start_date, end_date, area,\",\n \"the data. # # # Modules # # Standard Python Modules import math,\",\n \"MIN({3}{4}) AS min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE\",\n \"!= None else \\\"NULL\\\", elem[2] if elem[2] != None else \\\"NULL\\\", ) for\",\n \"AS index, non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events\",\n \"# \\\\ / / / # \\\\ / / / # \\\\/ /\",\n \"in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") result\",\n \"for the regular expression in each record of the vColumn. The vColumn will\",\n \"the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\", y, [str]), (\\\"nbins\\\", nbins, [int])]) self.parent.are_namecols_in(y)\",\n \"= executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias,\",\n \"i in range(1, n): trans += \\\"WHEN {} BETWEEN {} AND {} THEN\",\n \"(h > 1) or (self.category() == \\\"float\\\"): trans = ( \\\"'[' || FLOOR({}\",\n \"vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in\",\n \"Information Value (IV) / Weight Of Evidence (WOE) Table. It tells the predictive\",\n \"+= self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias,\",\n \"of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def plot( self,\",\n \"Apache License, Version 2.0 (the \\\"License\\\"); # You may not use this file\",\n \"self.parent.to_db(tmp_view_name) from verticapy.learn.ensemble import ( RandomForestClassifier, RandomForestRegressor, ) drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() ==\",\n \"vDataFrame[].get_dummies : Encodes the vColumn with One-Hot Encoding. vDataFrame[].mean_encode : Encodes the vColumn\",\n \"--------------------------------------------------------------------------- Returns the vColumn memory usage. Returns ------- float vColumn memory usage (byte)\",\n \"AS {} FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER\",\n \"as Response Column.\\\".format( self.alias, response ) ) if verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was\",\n \"floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h > 1)\",\n \"Rounds the vColumn by keeping only the input number of digits after the\",\n \"testing to be able to look at the final transformation. Returns ------- vDataFrame\",\n \"or (upper != None), ParameterError( \\\"At least 'lower' or 'upper' must have a\",\n \"(Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate : Computes\",\n \"{}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1 )\",\n \"str) or not (isinstance(cat_priority, Iterable)): cat_priority = [cat_priority] check_types( [ (\\\"by\\\", by, [str]),\",\n \") desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\")) else \\\" DESC\\\" partition_by\",\n \"([0, 1], [1, 0]) or self.isbool(): all_new_features = [] prefix = ( self.alias.replace('\\\"',\",\n \"[item[0] for item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False\",\n \"MILLISECONDS / MINUTE / MONTH / QUARTER / SECOND / TIME ZONE /\",\n \"available on type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias],\",\n \"\\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold * result[\\\"std\\\"][0]\",\n \"/ DECADE / DOQ / DOW / DOY / EPOCH / HOUR /\",\n \"self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns) ), print_time_sql=False,\",\n \"+= [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try: sauv = {}\",\n \"10) return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \\\"\\\",\",\n \"\\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\"\",\n \"method 'same_freq'\\\" ) count = self.count() nb = int(float(count / int(nbins))) assert nb\",\n \"h will be picked or computed) ax: Matplotlib axes object, optional The axes\",\n \"/~\\\\ _ |. # |_)\\\\/ |_)(_|(_|| \\\\_/|_|(_||| # / # ____________ ______ #\",\n \"result[i], result[i - 1], result[i] ) trans += \\\" ELSE NULL END)\\\" trans\",\n \"Draws the pie chart of the vColumn based on an aggregation. Parameters ----------\",\n \"optional Uses the Gaussian distribution to define the outliers. After normalizing the data\",\n \"'Others', SUM(count) FROM (SELECT COUNT(*) AS count\\\" \\\" FROM vdf_table WHERE {0} IS\",\n \"= \\\"Describes the statics of {} partitioned by {}.\\\".format( numcol, self.alias ) values\",\n \"be binary to use iv_woe.\\\".format(y) ) response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat ==\",\n \"if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\",\",\n \"of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by: str\",\n \"alias: str vColumn alias. transformations: list, optional List of the different transformations. Each\",\n \"named {} was added to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent\",\n \"See Also -------- vDataFrame.iv_woe : Computes the Information Value (IV) Table. \\\"\\\"\\\" check_types([(\\\"y\\\",\",\n \"categorical. numcol: str, optional Numerical vColumn to use when the parameter method is\",\n \"self.transformations ) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations +=\",\n \"to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] == None: pass\",\n \"has no mode (only missing values).\\\\nNothing was filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return\",\n \"the Matplotlib functions. Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist\",\n \"(date, datetime ...), the parameter 'x' will represent the number of seconds, otherwise\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user\",\n \"\\\", \\\".join(by) ), ) else: avg, stddev = ( \\\"AVG({}) OVER (PARTITION BY\",\n \"return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [\",\n \"k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\" if (k < 1)\",\n \"'categorical' otherwise. categorical : Uses only categorical aggregations during the computation. cat_stats :\",\n \"vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h\",\n \"if (dropna) else \\\"\\\" query = \\\"SELECT {} AS {}, COUNT(*) AS _verticapy_cnt_,\",\n \"'{}') > 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\"\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].dropna : Drops the vColumn missing values.\",\n \"- min) / (max - min) by: list, optional vColumns used in the\",\n \"# ---# def iv_woe(self, y: str, nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \"in result if elem[1] != None ] ), ) cmax = \\\"DECODE({}, {},\",\n \"# ---# def bar( self, method: str = \\\"density\\\", of: str = \\\"\\\",\",\n \"for the mode) topk_percent : kth most occurent element density unique : cardinality\",\n \"total < int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb\",\n \"return to_tablesample(query, title=title) # ---# def normalize( self, method: str = \\\"zscore\\\", by:\",\n \"\\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\" if labels: label\",\n \"/ # |____/ / / # _____________ / / # \\\\ / /\",\n \"the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled with\",\n \"+= [ (\\\"{}\\\", self.ctype(), self.category()) ] self.parent[copy_name].transformations += [(func, ctype, category)] self.parent[copy_name].catalog =\",\n \"index_stop = index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0\",\n \"compute the Equal Frequency discretization\\\" ) total, query, nth_elems = nb, [], []\",\n \"if (self.isnum() and self.nunique(True) > 6) else \\\"mode\\\" total = self.count() if (method\",\n \"int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where = \\\"WHERE _verticapy_row_nb_\",\n \"field: str The field to extract. It must be one of the following:\",\n \"Returns the distinct categories of the vColumn. Returns ------- list Distinct caterogies of\",\n \"{}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn\",\n \"except: pass total = int(total) conj = \\\"s were \\\" if total >\",\n \"{column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\"\",\n \"method is set to 'cat_stats'. Returns ------- tablesample An object containing the result.\",\n \"query += [lp + tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT\",\n \"and 1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower()\",\n \"self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0\",\n \"(SELECT split_value, MAX(weighted_information_gain) FROM ({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY\",\n \"non_events, SUM({}) AS events FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y,\",\n \"used in the partition. return_trans: bool, optimal If set to True, the method\",\n \"Returns the nth most occurent element. Parameters ---------- dropna: bool, optional If set\",\n \") # ---# def product(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'product'. Returns\",\n \"= ( 100 * (int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total\",\n \"\\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def date_part(self, field: str): \\\"\\\"\\\"\",\n \"aggregation. Parameters ---------- method: str, optional The method to use to aggregate the\",\n \"performance can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See\",\n \"Returns True if the vColumn is boolean. vDataFrame[].isnum : Returns True if the\",\n \"when 'ts' is lesser than November 1993 the 3rd. end_date: str / date,\",\n \"] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold\",\n \"result[7], ) elif self.isdate(): min_date = self.min() table = \\\"(SELECT DATEDIFF('second', '{}'::timestamp, {})\",\n \"\\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\\",\n \"as one column of that relation. vColumns simplify several processes with its abstractions.\",\n \"use this file except in compliance with the License. # You may obtain\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"kurtosis\\\"]).values[self.alias][0] kurt =\",\n \"conj)) self.parent.__add_to_history__( \\\"[Fillna]: {} {} missing value{} filled.\\\".format( total, self.alias, conj, ) )\",\n \"self elif method == \\\"minmax\\\": if n == 0: nullifzero = 0 cmin,\",\n \"({}) x GROUP BY 1\\\".format( self.alias, y, y, query, ) query = \\\"SELECT\",\n \"not be considered during the computation. n: int, optional Integer corresponding to the\",\n \"float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the histogram of the\",\n \"x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{}\",\n \"= (self.max() - self.min()) * 1.01 / nbins if h > 0.01: h\",\n \"invalid. max_cardinality: int, optional Maximum number of vColumn distinct elements to be used\",\n \"bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ----------\",\n \"OFFSET {}{}) VERTICAPY_SUBTABLE\\\".format( self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index,\",\n \"vDataFrame[].decode : Encodes the vColumn using a user-defined encoding. vDataFrame[].discretize : Discretizes the\",\n \"\\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] != None\",\n \"+ 1 or parameter 'labels' must be empty.\\\" ) conditions, column = [],\",\n \".replace(\\\"/\\\", \\\"_\\\") .replace(\\\",\\\", \\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format(\",\n \"int): \\\"\\\"\\\" --------------------------------------------------------------------------- Slices the vColumn. The vColumn will be transformed. Parameters ----------\",\n \"{} AS {}, COUNT(*) AS _verticapy_cnt_, 100 * COUNT(*) / {} AS percent\",\n \"column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format( self.parent.__genSQL__(force_columns=force_columns)\",\n \"DESC LIMIT {1})\\\"\\\"\\\".format( self.alias, max_cardinality ) if distinct_count > max_cardinality: query += (\",\n \"Sturges [CEIL(log2(n)) + 1] Returns ------- float optimal bar width. \\\"\\\"\\\" check_types( [(\\\"method\\\",\",\n \"return self.aggregate([\\\"mad\\\"]).values[self.alias][0] # ---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max'\",\n \"Returns the n largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query =\",\n \"box plot of the vColumn. Parameters ---------- by: str, optional vColumn to use\",\n \"start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format(\",\n \"str Response vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes\",\n \"()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format(\",\n \"int, optional Number of bins used for the discretization (must be > 1)\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({}, '{}', '{}')\\\".format(\",\n \"nbins: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the Information Value (IV) / Weight\",\n \"raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent # ---# def\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ) else: final_transformation = [ (\",\n \"November 1993 the 3rd. end_date: str / date, optional Input End Date. For\",\n \"val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and\",\n \"Lower bound. upper: float, optional Upper bound. Returns ------- vDataFrame self.parent See Also\",\n \"parent, vDataFrame : Parent of the vColumn. transformations, str : List of the\",\n \"'robust_zscore' is available only if the parameter 'by' is empty\\\\nIf you want to\",\n \": Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by,\",\n \"\\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\", \\\"float\\\", ) ] else: warning_message\",\n \"\\\"{}\\\", x) return self.apply(func=expr) # ---# def astype(self, dtype: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Converts\",\n \"of the following: date / int / float / text / binary /\",\n \") count = self.count() nb = int(float(count / int(nbins))) assert nb != 0,\",\n \"and bools), a RF Classifier otherwise. Example: Write {\\\"n_estimators\\\": 20, \\\"max_depth\\\": 10} to\",\n \"if the vColumn type is date like). The vColumn will be transformed. Parameters\",\n \"be created using the input Name. Returns ------- vDataFrame self.parent See Also --------\",\n \"== 1) and (self.parent[by[0]].nunique() < 50): try: if fun == \\\"MEDIAN\\\": fun =\",\n \"True if the vColumn category is date. See Also -------- vDataFrame[].isbool : Returns\",\n \"the box plot. The other categories will be filtered. ax: Matplotlib axes object,\",\n \"computed) nbins: int, optional Number of nbins. If empty, an optimized number of\",\n \"filled.\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self.parent if isinstance(val, str): val = val.replace(\\\"'\\\",\",\n \"to True, the intervals will be closed on the right. Returns ------- vDataFrame\",\n \": Average of the vColumn 'of'. min : Minimum of the vColumn 'of'.\",\n \"END)\\\".format( \\\"{}\\\", p_alpha, p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query =\",\n \"in result if elem[1] != None ] ), ) stddev = \\\"DECODE({}, {},\",\n \"vColumn '{}' was transformed with the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\",\",\n \"drop(tmp_model_name, method=\\\"model\\\") result = [self.min()] + result + [self.max()] elif method == \\\"topk\\\":\",\n \"self.parent.__genSQL__(), \\\" UNION ALL \\\".join(query) ) title = \\\"Describes the statics of {}\",\n \"p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose() .values[self.alias] ) self.parent.filter(\",\n \"the number of matches for the regular expression in each record of the\",\n \"should be closed. If set to True, the intervals will be closed on\",\n \"start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\",\",\n \"compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn distinct elements\",\n \"[str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts\",\n \"1 otherwise. expr: str, optional SQL expression. by: list, optional vColumns used in\",\n \"True, right: bool = True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the\",\n \"< int(float(count / int(nbins))) * int(nbins): nth_elems += [str(total)] total += nb where\",\n \"= False, n: int = 1): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the nth most occurent\",\n \"---------- add_history: bool, optional If set to True, the information will be stored\",\n \": absolute value acos : trigonometric inverse cosine asin : trigonometric inverse sine\",\n \"vColumn using the input functions. Parameters ---------- func: list List of the different\",\n \"not empty, a copy will be created using the input Name. Returns -------\",\n \"FROM ({}) x GROUP BY 1\\\".format( self.alias, y, y, query, ) query =\",\n \"== \\\"donut\\\" else False rose = True if pie_type == \\\"rose\\\" else False\",\n \"vColumn. Parameters ---------- func: str Function to use to transform the vColumn. abs\",\n \"and mad). (x - median) / (1.4826 * mad) minmax : Normalization using\",\n \"[xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp,\",\n \"License. # # |_ |~) _ _| _ /~\\\\ _ |. # |_)\\\\/\",\n \"return best_h # ---# def nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates\",\n \"item in executeSQL( query=query, title=\\\"Computing the average of the {}'s lower and upper\",\n \"pat, [str])]) return self.apply( func=\\\"REGEXP_SUBSTR({}, '{}')\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_replace(self,\",\n \"# ---# def div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the\",\n \"|| FLOOR({} / {}) * {} || ';' || (FLOOR({} / {}) *\",\n \"if 'use_threshold' is set to False else the lower and upper ZScores. threshold:\",\n \"--------------------------------------------------------------------------- Returns True if the vColumn is numerical, False otherwise. Returns ------- bool\",\n \"approx_unique : approximative cardinality count : number of non-missing elements cvar : conditional\",\n \"from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax,\",\n \"\\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM vdf_table WHERE {}\",\n \"[], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using\",\n \"\\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\\",\n \"/ # \\\\/ # _ # \\\\ / _ __|_. _ _ |_)\",\n \") self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\":\",\n \"close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\", \\\"]\\\"\",\n \"# distributed under the License is distributed on an \\\"AS IS\\\" BASIS, #\",\n \"-------- vDataFrame[].decode : Encodes the vColumn with a user defined Encoding. vDataFrame[].discretize :\",\n \"def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters ---------- *args\",\n \"# data science projects on data stored in Vertica, taking advantage Vertica’s #\",\n \"composed of two flower brackets {}. For example to apply the function: x\",\n \"return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index)\",\n \"{0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE) ORDER BY count DESC\\\"\",\n \"\\\"[\\\", \\\"[\\\" if idx == 0 and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\"\",\n \"vColumn. Parameters ---------- n: int, optional Offset. Returns ------- tablesample An object containing\",\n \"EPOCH / HOUR / ISODOW / ISOWEEK / ISOYEAR / MICROSECONDS / MILLENNIUM\",\n \"{} FROM (SELECT {}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY\",\n \"vColumn type must be date like (date, datetime, timestamp...) or numerical. q: tuple,\",\n \"e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") ) ) # ---# def apply_fun(self, func: str,\",\n \"\\\"bool\\\" else: category, ctype = self.category(), self.ctype() copy_trans = [elem for elem in\",\n \"use to discretize the vColumn. auto : Uses method 'same_width' for numerical vColumns,\",\n \"{}\\\".format(limit) else: limit = \\\"\\\" query = \\\"(SELECT {} FROM {}{} OFFSET {}{})\",\n \"tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn is\",\n \"vColumn. labels: list, optional Labels used to name the new categories. If empty,\",\n \"{})\\\".format(field, \\\"{}\\\")) # ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using\",\n \"method, [\\\"zscore\\\", \\\"robust_zscore\\\", \\\"minmax\\\"]), (\\\"by\\\", by, [list]), (\\\"return_trans\\\", return_trans, [bool]), ] ) method\",\n \"simple: instead of moving # data around for processing, VerticaPy brings the logic\",\n \"LIMIT 1\\\".format( cmax, cmin, self.parent.__genSQL__() ), print_time_sql=False, ) except: cmax, cmin = (\",\n \"def cut( self, breaks: list, labels: list = [], include_lowest: bool = True,\",\n \"if fun == \\\"AVG\\\": val = self.avg() elif fun == \\\"MEDIAN\\\": val =\",\n \"\\\\ \\\\ \\\\-./\\\\ \\\\ \\\\ \\\\ \\\\-. \\\\ # \\\\ \\\\__| \\\\ \\\\_____\\\\\",\n \"MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias, self.parent.shape()[0], numcol, cast, ) tmp_query +=\",\n \"list. Parameters ---------- breaks: list List of values used to cut the vColumn.\",\n \"assert len(breaks) == len(labels) + 1 or not (labels), ParameterError( \\\"Length of parameter\",\n \"= \\\"WITH vdf_table AS (SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), \\\" UNION ALL\",\n \"---------- new_name: str The new vColumn alias. Returns ------- vDataFrame self.parent See Also\",\n \"= \\\"\\\" if (n == 1) else str(int(n)) if isinstance(top, decimal.Decimal): top =\",\n \"p_1_alpha, \\\"{}\\\" ) ) elif method == \\\"mean\\\": query = \\\"WITH vdf_table AS\",\n \"encoding was successfully done.\\\") return self.parent # ---# def median( self, approx: bool\",\n \"the vColumn type is date like). The vColumn will be transformed. Parameters ----------\",\n \"IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, ) result\",\n \"(\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ] ) distinct_elements = self.distinct() if distinct_elements not in ([0,\",\n \"the function has two arguments (example, power or mod), 'x' represents the second\",\n \"\\\"or simply because of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters\",\n \"return_enum_trans: bool, optional Returns the transformation instead of the vDataFrame parent and do\",\n \"first preparing your data. Parameters ---------- new_name: str The new vColumn alias. Returns\",\n \"FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY\",\n \"of: str = \\\"\\\", max_cardinality: int = 6, nbins: int = 0, h:\",\n \"applying the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\")\",\n \"elem: if \\\"percent\\\" in elem: self.catalog[elem] = sauv[elem] elif elem == None: self.catalog[elem]\",\n \"query = \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(),\",\n \"== \\\"sturges\\\": best_h = sturges elif method.lower() in (\\\"freedman_diaconis\\\", \\\"fd\\\"): best_h = fd\",\n \"else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item\",\n \"user defined Encoding. vDataFrame[].discretize : Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn\",\n \"can drastically decrease. Returns ------- int vColumn cardinality (or approximate cardinality). See Also\",\n \"(SELECT * FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing\",\n \"best splits when 'method' is set to 'smart'. A RF Regressor will be\",\n \"= executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result =\",\n \"The field to extract. It must be one of the following: CENTURY /\",\n \"{}) / ({})\\\".format(self.alias, med, mad) else: final_transformation = [ ( \\\"({} - {})\",\n \"self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns = [self.alias] if\",\n \"self.parent.get_columns(), 0 for column in all_cols: try: if (quote_ident(column) in func) or (\",\n \"= self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] + result[\\\"avg\\\"][0], threshold\",\n \"self.category(), self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count() if\",\n \"Plot. start_date: str / date, optional Input Start Date. For example, time =\",\n \"= model.fit(self.parent.__genSQL__(), [self.alias]).plot( ax=ax, **style_kwds ) model.drop() return result except: model.drop() raise #\",\n \"columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower()\",\n \"round(h, 2) elif h > 0.0001: h = round(h, 4) elif h >\",\n \": interquartile range kurtosis : kurtosis jb : Jarque-Bera index mad : median\",\n \"value to a specified number of decimal places sign : arithmetic sign sin\",\n \"the input list. Parameters ---------- breaks: list List of values used to cut\",\n \"{} missing value{} filled.\\\".format( total, self.alias, conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing\",\n \"parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements\",\n \"pure SQL used to transform the vColumn. The function variable must be composed\",\n \"sign sin : trigonometric sine sinh : hyperbolic sine sqrt : arithmetic square\",\n \"title=\\\"Computing the Store Usage of the vColumn {}.\\\".format(self.alias), method=\\\"fetchfirstelem\\\", ) self.parent.__update_catalog__( {\\\"index\\\": [\\\"store_usage\\\"],\",\n \"of the vColumn record by an input value. The vColumn will be transformed.\",\n \"-= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [ (\\\"{}\\\",\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.drop: Drops the input vColumns from the\",\n \"to get the median). It can also be a cutomized aggregation (ex: AVG(column1)\",\n \"NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1, APPROXIMATE_PERCENTILE({}\",\n \"nbins: int = 0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"using as lower bound quantile(alpha) and as upper bound quantile(1-alpha) if 'use_threshold' is\",\n \"= gen_tmp_name(schema=schema, name=\\\"model\\\") assert nbins >= 2, ParameterError( \\\"Parameter 'nbins' must be greater\",\n \"Also -------- vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name,\",\n \"max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"quantile (ex: 50% for the median) prod : product range : difference between\",\n \"set to True, the intervals will be closed on the right. Returns -------\",\n \"{}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method\",\n \": Computes regular width bins. smart : Uses the Random Forest on a\",\n \"= \\\"SELECT {}, {}({}) FROM {} GROUP BY {};\\\".format( by[0], fun, self.alias, self.parent.__genSQL__(),\",\n \"plot( self, ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] =\",\n \"/ # \\\\ / # \\\\ / # \\\\/ # _ # \\\\\",\n \"the upper bound to the upper bound itself. Parameters ---------- lower: float, optional\",\n \"(tuple, list)): xlim_tmp = [xlim] else: xlim_tmp = [] model = KernelDensity( name,\",\n \"\\\"round\\\"): expr = \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return\",\n \"verticapy.options[\\\"print_info\\\"]: print(\\\"The mean encoding was successfully done.\\\") return self.parent # ---# def median(\",\n \"({} ORDER BY {}))\\\".format( \\\"{}\\\", \\\"{}\\\", partition_by, order_by_ts ) if method in (\\\"mean\\\",\",\n \"= \\\"SELECT * FROM {} WHERE {} IS NOT NULL ORDER BY {}\",\n \"the vColumn 'of'. max : Maximum of the vColumn 'of'. sum : Sum\",\n \"trans = ( \\\"'[' || FLOOR({} / {}) * {} || ';' ||\",\n \"vdf_table WHERE {0} IS NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\"\",\n \"was added to the vDataFrame.\\\".format( self.alias, name ) ) return self.parent # ---#\",\n \") result = [distinct_count] + result index = [ \\\"unique\\\", \\\"count\\\", \\\"mean\\\", \\\"std\\\",\",\n \"self.alias: result}) for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal):\",\n \"AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(), ) query =\",\n \"descriptive statistics. \\\"\\\"\\\" check_types([(\\\"k\\\", k, [int, float]), (\\\"dropna\\\", dropna, [bool])]) topk = \\\"\\\"\",\n \"optional Maximum number of nbins used for the discretization (must be > 1)\",\n \"it can be 'minute' 'hour'... start: bool, optional If set to True, the\",\n \"+ sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in self.catalog: total += sys.getsizeof(elem) return\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame.donut : Draws the\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\") assert\",\n \"---------- to_replace: str Regular expression to replace. value: str, optional New value. Returns\",\n \"ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def rename(self, new_name:\",\n \"look at the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode\",\n \"ELSE ZEROIFNULL(LN(pt_non_events / NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR\",\n \"10 logarithm mod : remainder of a division operation pow : number raised\",\n \"---# def str_extract(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts the regular expression in each\",\n \"to the input vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n))\",\n \"BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\",\n \"\\\".join(by) ), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else:\",\n \"optional Numerical vColumn to use when the parameter method is set to 'cat_stats'.\",\n \"---------- method: str, optional Method to use to normalize. zscore : Normalization using\",\n \"n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title)\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest\",\n \"a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required\",\n \"BY {}\\\".format( \\\", \\\".join([quote_ident(column) for column in by]) ) if (by) else \\\"\\\"\",\n \"vColumn (delimited by an offset and a limit). Parameters ---------- limit: int, optional\",\n \"int(total) conj = \\\"s were \\\" if total > 1 else \\\" was\",\n \"sliced using the floor of the slicing instead of the ceiling. Returns -------\",\n \"(Constant Interpolation). ffill : Propagation of the first element (Constant Interpolation). mean :\",\n \"mean = avg # ---# def bar( self, method: str = \\\"density\\\", of:\",\n \"response_cat = self.parent[y].distinct() response_cat.sort() assert response_cat == [0, 1], TypeError( \\\"vColumn {} must\",\n \"query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()]\",\n \"5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the tail of the vColumn. Parameters ---------- limit: int,\",\n \"str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes\",\n \"---------- func: str Function to use to transform the vColumn. abs : absolute\",\n \"hist( self, method: str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int =\",\n \"(x - median) / (1.4826 * mad) minmax : Normalization using the MinMax\",\n \"= index.stop index_start = index.start if not (isinstance(index_start, int)): index_start = 0 if\",\n \"parent=self.parent, transformations=transformations, catalog={ \\\"min\\\": 0, \\\"max\\\": 1, \\\"count\\\": self.parent.shape()[0], \\\"percent\\\": 100.0, \\\"unique\\\": 2,\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame[].head : Returns the head of\",\n \"each of the vColumn records. vDataFrame[].extract : Extracts the regular expression in each\",\n \"unit.upper(), start_or_end ) ) # ---# def spider( self, by: str = \\\"\\\",\",\n \"= [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins, xlim=xlim_tmp, store=False, ) try:\",\n \"min) by: list, optional vColumns used in the partition. return_trans: bool, optimal If\",\n \"in distinct ] ), bin_spatial_to_str(self.category()), new_category.replace(\\\"'\\\", \\\"''\\\"), ), \\\"varchar\\\", \\\"text\\\", ) elif self.isnum()\",\n \"print_time_sql=False, ) except: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias,\",\n \"QUARTER / SECOND / TIME ZONE / TIMEZONE_HOUR / TIMEZONE_MINUTE / WEEK /\",\n \"science projects on data stored in Vertica, taking advantage Vertica’s # speed and\",\n \"Weight Of Evidence (WOE) Table. It tells the predictive power of an independent\",\n \"query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) # ---#\",\n \"will increase the precision but will also increase the time of the learning\",\n \"Also -------- vDataFrame.boxplot : Draws the Box Plot of the input vColumns. \\\"\\\"\\\"\",\n \"of the vColumns 1 and 2 bars. It is only valid if the\",\n \"\\\"{}\\\", p_1_alpha, mean_1_alpha, \\\"{}\\\" ) ) return self.parent # ---# def fillna( self,\",\n \"(or approximate cardinality). See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"Parent of the vColumn. transformations, str : List of the different transformations. \\\"\\\"\\\"\",\n \"return result except: model.drop() raise # ---# def describe( self, method: str =\",\n \"str_sql): func = str(func) check_types([(\\\"func\\\", func, [str]), (\\\"copy_name\\\", copy_name, [str])]) try: try: ctype\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns ------- list Distinct\",\n \"offset. For example, if n = 1 then this method will return the\",\n \"For more information, see utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n\",\n \"x ORDER BY ord\\\".format( self.alias, query, ) title = \\\"Computing WOE & IV\",\n \"the method on the vColumn \\\" \\\"or simply because of ambiguous columns naming.\\\\nBy\",\n \"method to use to aggregate the data. count : Number of elements. density\",\n \"computed if the parameter is empty or invalid. max_cardinality: int/tuple, optional Maximum number\",\n \"values. auto : Mean for the numerical and Mode for the categorical vColumns.\",\n \"lower, lower) if (isinstance(lower, (float, int))) else \\\"\\\" ) upper_when = ( \\\"WHEN\",\n \": Silverman kernel. nbins: int, optional Maximum number of points to use to\",\n \"# ---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute\",\n \"distinct categories of the vColumn. Returns ------- list Distinct caterogies of the vColumn.\",\n \"\\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\", cmax, cmin, ), \\\"float\\\", \\\"float\\\", ) ] if\",\n \"(ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {} IS NOT NULL) VERTICAPY_SUBTABLE\",\n \"LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format( \\\" UNION ALL \\\".join(query), nbins - 1\",\n \"({}) VERTICAPY_SUBTABLE WHERE split_value IS NOT NULL GROUP BY 1 ORDER BY 2\",\n \"NOT NULL GROUP BY {0} ORDER BY COUNT(*)\\\" \\\" DESC OFFSET {1}) VERTICAPY_SUBTABLE)\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"prefix\\\", prefix,\",\n \"'{}', '{}')\\\".format( \\\"{}\\\", length, unit.upper(), start_or_end ) ) # ---# def spider( self,\",\n \"the x limits of the current axes. ax: Matplotlib axes object, optional The\",\n \"inverse tangent cbrt : cube root ceil : value up to the next\",\n \"self.apply( func=\\\"(CASE WHEN ({} BETWEEN {} AND {}) THEN {} ELSE NULL END)\\\".format(\",\n \"sine sqrt : arithmetic square root tan : trigonometric tangent tanh : hyperbolic\",\n \"in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias]\",\n \"The method to use to discretize the vColumn. auto : Uses method 'same_width'\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx: return self.aggregate(func=[\\\"approx_unique\\\"]).values[self.alias][0] else:\",\n \"/ # VerticaPy is a Python library with scikit-like functionality for conducting #\",\n \"nbins, [int, float]), (\\\"h\\\", h, [int, float]), ] ) if of: self.parent.are_namecols_in(of) of\",\n \"new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1])\",\n \"div(self, x: float): \\\"\\\"\\\" --------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters\",\n \"to use to evaluate the approximate density function. Increasing this parameter will increase\",\n \"n = 1 if drop_first else 0 for k in range(len(distinct_elements) - n):\",\n \"\\\"approx_50%\\\", \\\"approx_75%\\\", \\\"max\\\", ] if method != \\\"cat_stats\\\": values = { \\\"index\\\": [\\\"name\\\",\",\n \"= get_dummies # ---# def head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns\",\n \"nlargest(self, n: int = 10): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the n largest vColumn elements.\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame.apply : Applies functions to the input\",\n \"\\\"_\\\") .replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\")\",\n \"\\\"\\\" for category in cat: tmp_query = \\\"\\\"\\\"SELECT '{0}' AS 'index', COUNT({1}) AS\",\n \"[str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step, [bool]), ] ) self.parent.are_namecols_in(ts) ts\",\n \"self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} + ({})\\\".format(\\\"{}\\\", x)) # ---# def\",\n \"return self.describe(method=\\\"categorical\\\", max_cardinality=k) # ---# def var(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \") if return_trans: return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if\",\n \"slice(self, length: int, unit: str = \\\"second\\\", start: bool = True): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"is empty or invalid. max_cardinality: int/tuple, optional Maximum number of distinct elements for\",\n \"vDataFrame self.parent See Also -------- vDataFrame.case_when : Creates a new feature by evaluating\",\n \"\\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", ) for elem in result\",\n \"for elem in values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] =\",\n \"self, val=None, method: str = \\\"auto\\\", expr: str = \\\"\\\", by: list =\",\n \"in range(len(result)): if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg\",\n \"the func 'x -> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for\",\n \"of moving # data around for processing, VerticaPy brings the logic to the\",\n \"[float(round(item[2], 3)) for item in result], } return tablesample(values) # ---# def value_counts(self,\",\n \"[ f\\\"'{first_elem}' {op1} {column} AND {column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr =\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx: bool, optional If set\",\n \"for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT 10\\\".format(\",\n \"the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set to\",\n \"import * ## # # __ __ ______ ______ __ __ __ __\",\n \"used as categorical (No h will be picked or computed) h: float, optional\",\n \"the search. Parameters ---------- val: list List of the different records. For example,\",\n \"cast = \\\"::float\\\" if self.category() == \\\"float\\\" else \\\"\\\" if index < 0:\",\n \"is date like (date, datetime ...), the parameter 'x' will represent the number\",\n \"{} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(),\",\n \"different transformations. Each transformation must be similar to the following: (function, type, category)\",\n \"stddev ) else: final_transformation = [ ( \\\"({} - {}) / {}({})\\\".format( \\\"{}\\\",\",\n \"[ (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins,\",\n \"of values used to cut the vColumn. labels: list, optional Labels used to\",\n \"= index_stop - index_start if limit <= 0: limit = 0 limit =\",\n \"changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve\",\n \"return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self, method: str =\",\n \"FROM {} WHERE {} IS NOT NULL GROUP BY {} ORDER BY {}\\\".format(\",\n \"\\\"float\\\"): trans = ( \\\"'[' || FLOOR({} / {}) * {} || ';'\",\n \"occurent element (ex: top1 for the mode) topk_percent : kth most occurent element\",\n \"distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of the vColumn. Returns -------\",\n \"IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\", ) except:\",\n \"conj, ) ) else: if verticapy.options[\\\"print_info\\\"]: print(\\\"Nothing was filled.\\\") self.transformations = [elem for\",\n \"[str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be\",\n \"float = 0, pie_type: str = \\\"auto\\\", ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws\",\n \"vColumn using 'std' (Standard Deviation). Returns ------- float std See Also -------- vDataFrame.aggregate\",\n \"vDataFrame expected store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"\\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]), ] ) if func\",\n \"list of at least one element to use to order the data\\\" )\",\n \"vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"approx\\\", approx, [bool])]) if approx:\",\n \"\\\"auto\\\", h: float = 0, nbins: int = -1, k: int = 6,\",\n \"args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check = False if\",\n \"self.ctype() copy_trans = [elem for elem in self.transformations] total = self.count() if method\",\n \"record by an input value. The vColumn will be transformed. Parameters ---------- to_replace:\",\n \"more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds a new vColumn\",\n \"query = \\\"SELECT {}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains : Verifies if the regular expression\",\n \"method to 'numerical' if the vColumn is numerical , 'categorical' otherwise. categorical :\",\n \"\\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) elif method in (\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"):\",\n \"int, optional Maximum number of the vColumn distinct elements to be used as\",\n \"{} partitioned by {}.\\\".format( numcol, self.alias ) values = to_tablesample(query, title=title).values elif (\",\n \"after the comma. Parameters ---------- n: int Number of digits to keep after\",\n \"axes object See Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types(\",\n \"= self.parent.shape()[0] self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to\",\n \"ASC LIMIT 1\\\".format( self.alias, self.alias, self.parent.__genSQL__(), where, self.alias, n ), title=\\\"Computing the mode.\\\",\",\n \"the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---# def\",\n \"following: date / int / float / text / binary / spatial /\",\n \"be date like (date, datetime, timestamp...) or numerical. q: tuple, optional Tuple including\",\n \"---# def clip(self, lower=None, upper=None): \\\"\\\"\\\" --------------------------------------------------------------------------- Clips the vColumn by transforming the\",\n \"= self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by) == 1) and (self.parent[by[0]].nunique()\",\n \"\\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem in order_by] for elem in\",\n \"float product See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\"\",\n \"number of matches for the regular expression in each record of the vColumn.\",\n \"( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\",\",\n \"the vColumn using a time series rule. \\\"\\\"\\\" return self.apply(func=\\\"DATE_PART('{}', {})\\\".format(field, \\\"{}\\\")) #\",\n \"\\\"{}\\\", result[i - 1], result[i], result[i - 1], result[i] ) trans += \\\"\",\n \"\\\"mean\\\": query = \\\"WITH vdf_table AS (SELECT * FROM {}) (SELECT AVG({}) FROM\",\n \"vColumn distinct elements to be used as categorical (No h will be picked\",\n \"\\\"\\\"\\\" if \\\"agg\\\" not in kwargs: query = \\\"SELECT {} AS {} FROM\",\n \"non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events / NULLIFZERO(SUM(events) OVER\",\n \": Gaussian kernel. logistic : Logistic kernel. sigmoid : Sigmoid kernel. silverman :\",\n \"See Also -------- vDataFrame.plot : Draws the time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\",\",\n \"use to compute the aggregation. h: int/float/tuple, optional Interval width of the vColumns\",\n \"for column in order_by]) new_column = \\\"COALESCE({}, LAST_VALUE({} IGNORE NULLS) OVER ({} ORDER\",\n \"Discretizes the vColumn using the input list. Parameters ---------- breaks: list List of\",\n \"vdf_table WHERE {} < {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {}\",\n \"pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches for the regular expression\",\n \"std See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return\",\n \"each of the vColumn records by an input value. vDataFrame[].str_slice : Slices the\",\n \"Donut chart. rose : Rose chart. It can also be a cutomized aggregation\",\n \"if the vColumn is numerical. \\\"\\\"\\\" return self.ctype().lower() in (\\\"bool\\\", \\\"boolean\\\") # ---#\",\n \"and built-in analytics and machine learning features. It supports the # entire data\",\n \"the slicing. step: int Size of the slicing. Returns ------- vDataFrame self.parent See\",\n \"def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'count' (Number of non-Missing elements).\",\n \"to use to compute the optimal h. auto : Combination of Freedman Diaconis\",\n \"to order the data\\\" ) desc = \\\"\\\" if (method in (\\\"ffill\\\", \\\"pad\\\"))\",\n \"= nb, [], [] while total < int(float(count / int(nbins))) * int(nbins): nth_elems\",\n \"dropna: bool, optional If set to True, NULL values will not be considered\",\n \"self.aggregate(func=[\\\"unique\\\"]).values[self.alias][0] # ---# def pie( self, method: str = \\\"density\\\", of: str =\",\n \"list = [], return_trans: bool = False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input\",\n \"bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Drops the vColumn from the vDataFrame. Dropping a\",\n \"copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval : Evaluates a customized\",\n \"keeping only the input number of digits after the comma. Parameters ---------- n:\",\n \"result], } return tablesample(values) # ---# def value_counts(self, k: int = 30): \\\"\\\"\\\"\",\n \"a Step Plot. ax: Matplotlib axes object, optional The axes to plot on.\",\n \"\\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] ) method = method.lower()\",\n \"(\\\"start\\\", start, [bool]), ] ) start_or_end = \\\"START\\\" if (start) else \\\"END\\\" return\",\n \"will not be considered during the computation. n: int, optional Integer corresponding to\",\n \"method=\\\"fetchall\\\", ) return [item for sublist in query_result for item in sublist] #\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"max\\\"]).values[self.alias][0] # ---# def mean_encode(self, response: str): \\\"\\\"\\\"\",\n \"\\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) ) else: new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION\",\n \"self.min() xmax = self.max() else: xmin, xmax = xlim custom_lines = [] columns\",\n \"alias. transformations: list, optional List of the different transformations. Each transformation must be\",\n \"vDataFrame of the search. Parameters ---------- val: list List of the different records.\",\n \"x, [int, float]), ] ) if func not in (\\\"log\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\"):\",\n \"'alpha' parameter. alpha: float, optional Number representing the outliers threshold. Values lesser than\",\n \"val: int/float/str, optional Value to use to impute the vColumn. method: dict, optional\",\n \"---# def __getitem__(self, index): if isinstance(index, slice): assert index.step in (1, None), ValueError(\",\n \"[str]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"nbins\\\", nbins, [int, float]), (\\\"h\\\", h, [int, float]),\",\n \"False ): \\\"\\\"\\\" --------------------------------------------------------------------------- Normalizes the input vColumns using the input method. Parameters\",\n \"self.parent # ---# def distinct(self, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the distinct categories of\",\n \"True if the vColumn is boolean, False otherwise. Returns ------- bool True if\",\n \"greater than the threshold it will be considered as an outlier. use_threshold: bool,\",\n \"must be one of the following: CENTURY / DAY / DECADE / DOQ\",\n \"_ _ |_) # \\\\/ (/_| | |(_(_|| \\\\/ # / # VerticaPy\",\n \"vColumn by dropping the current vColumn and creating a copy with the specified\",\n \"# ---# def decode(self, *argv): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a user-defined\",\n \"parameter 'numcol' must be defined. numerical : Uses popular numerical aggregations during the\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined\",\n \"elements, please use a method in zscore|minmax\\\" warnings.warn(warning_message, Warning) return self mad, med\",\n \"method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1])\",\n \"optional Uses numbers as suffix instead of the vColumns categories. Returns ------- vDataFrame\",\n \"a vColumn can make the vDataFrame \\\"heavier\\\" if it is used to compute\",\n \"MAD is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method ==\",\n \"cosine cot : trigonometric cotangent exp : exponential function floor : value down\",\n \"of the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type =\",\n \"vDataFrame[].str_contains : Verifies if the regular expression is in each of the vColumn\",\n \"chart of the vColumn based on an aggregation. \\\"\\\"\\\" if isinstance(pie_type, str): pie_type\",\n \"to True, the lowest element of the list will be included. right: bool,\",\n \"GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY split_value::float\\\".format(\",\n \"h, h, \\\"{}\\\", h, h, h, floor_end ), \\\"varchar\\\", \\\"text\\\", ) else: trans\",\n \"the vColumn memory usage. Returns ------- float vColumn memory usage (byte) See Also\",\n \"self.alias, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), limit, offset, ), title=title, ) tail.count = self.parent.shape()[0] tail.offset =\",\n \"isin(self, val: list, *args): \\\"\\\"\\\" --------------------------------------------------------------------------- Looks if some specific records are in\",\n \"---------- k: int, optional Number of most occurent elements to return. dropna: bool,\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---#\",\n \"Plot of the input vColumns. \\\"\\\"\\\" if isinstance(cat_priority, str) or not (isinstance(cat_priority, Iterable)):\",\n \"sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) total = abs(self.count() - total) except Exception as\",\n \"was renamed '{}'.\\\".format(old_name, new_name) ) return parent # ---# def round(self, n: int):\",\n \"> 0 else \\\"\\\", self.alias ), method=\\\"fetchall\\\", ) values = { \\\"index\\\": [item[0]\",\n \"nullifzero = 0 avg, stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message\",\n \"Standard Python Modules import math, re, decimal, warnings, datetime from collections.abc import Iterable\",\n \"FROM {} WHERE {} IS NOT NULL ORDER BY {} ASC LIMIT {}\\\".format(\",\n \"): n = len(result) trans = \\\"(CASE \\\" for i in range(1, n):\",\n \"\\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\",\",\n \"self.parent.format_colnames(ts) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot import ts_plot return ts_plot(\",\n \"# ---# def geo_plot(self, *args, **kwargs): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Geospatial object. Parameters\",\n \"= args[0] elif \\\"column\\\" in kwargs: column = kwargs[\\\"column\\\"] else: check = False\",\n \"!= \\\"numerical\\\")) or not (is_numeric) or (method == \\\"categorical\\\") ): query = \\\"\\\"\\\"(SELECT\",\n \"0, h: float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar\",\n \"to_tablesample(query, title=title).values elif ( ((distinct_count < max_cardinality + 1) and (method != \\\"numerical\\\"))\",\n \"time series. \\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"q\\\", q, [tuple]), ( \\\"start_date\\\",\",\n \"len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation\",\n \"---------- method: str, optional The describe method. auto : Sets the method to\",\n \"the transformation instead of the vDataFrame parent and do not apply it. This\",\n \"it will be considered as an outlier. use_threshold: bool, optional Uses the threshold\",\n \"using a Robust Z-Score - The MAD is null !\\\".format( self.alias ) warnings.warn(warning_message,\",\n \"\\\"{}\\\", by[0], \\\", \\\".join( [\\\"{}, {}\\\".format(elem[0], elem[1]) for elem in result] ), )\",\n \"# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to\",\n \"def fill_outliers( self, method: str = \\\"winsorize\\\", threshold: float = 4.0, use_threshold: bool\",\n \"if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if\",\n \"See Also -------- vDataFrame[].decode : Encodes the vColumn with user defined Encoding. vDataFrame[].discretize\",\n \"\\\"std\\\" ] elif method == \\\"minmax\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"min\\\"]) / (\",\n \"in each record of the vColumn. vDataFrame[].extract : Extracts the regular expression in\",\n \"vColumn records by an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\",\",\n \"the vColumn using the input method. Parameters ---------- method: str, optional The method\",\n \"--------------------------------------------------------------------------- Divides the vColumn by the input element. Parameters ---------- x: float Input\",\n \"a division operation pow : number raised to the power of another number\",\n \"------- float quantile (or approximate quantile). See Also -------- vDataFrame.aggregate : Computes the\",\n \"---# def aad(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'aad' (Average Absolute Deviation).\",\n \"the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic : Adds\",\n \"the dummies ({name}).\\\\n\\\" \\\"It can be the result of using previously the method\",\n \"= ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations) + sys.getsizeof(self.catalog) ) for elem in\",\n \"return pre_comp assert n >= 1, ParameterError(\\\"Parameter 'n' must be greater or equal\",\n \"Discretizes the vColumn using the input method. Parameters ---------- method: str, optional The\",\n \"* IQR / n ** (1 / 3)] sturges : Sturges [CEIL(log2(n)) +\",\n \"\\\"int\\\", \\\"float\\\") ] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Mean Encode]: The vColumn {} was transformed\",\n \"model.fit(tmp_view_name, [self.alias], response) query = [ \\\"(SELECT READ_TREE(USING PARAMETERS model_name = '{}', tree_id\",\n \"for elem in result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format(\",\n \"\\\"avg\\\", \\\"median\\\", \\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\", ], ), (\\\"expr\\\", expr, [str]), (\\\"by\\\", by,\",\n \"1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index, ) return executeSQL( query=query, title=\\\"Getting the vColumn\",\n \"in order_by] + by) by = self.parent.format_colnames(by) if method == \\\"auto\\\": method =\",\n \"cmax, cmin, ) else: final_transformation = [ ( \\\"({} - {}) / {}({}\",\n \"machine learning features. It supports the # entire data science life cycle, uses\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame.analytic :\",\n \"multiple children vColumns whereas one vColumn can only have one parent. catalog: dict,\",\n \"= [xlim] else: xlim_tmp = [] model = KernelDensity( name, bandwidth=bandwidth, kernel=kernel, nbins=nbins,\",\n \"else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False ) .transpose() .values[self.alias] ) result\",\n \"response column to find the most relevant interval to use for the discretization.\",\n \"[elem[0] for elem in result] except: drop(tmp_view_name, method=\\\"view\\\") drop(tmp_model_name, method=\\\"model\\\") raise drop(tmp_view_name, method=\\\"view\\\")\",\n \"+= list(args) check_types([(\\\"val\\\", val, [list])]) val = {self.alias: val} return self.parent.isin(val) # ---#\",\n \"method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN\",\n \"'{}' was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"),\",\n \"executeSQL( query, title=\\\"Computing the different aggregations.\\\", method=\\\"fetchall\\\", ) for idx, elem in enumerate(result):\",\n \"return \\\"({} - {}) / {}({})\\\".format( self.alias, avg, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"an input value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sum'. Returns ------- float sum See Also\",\n \"optional Method to use to impute the missing values. auto : Mean for\",\n \"parameter 'by' is empty\\\\nIf you want to normalize by grouping by elements, please\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame.fill_outliers : Fills the outliers in\",\n \"executeSQL( \\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias,\",\n \"= result.values[self.alias] elif (method == \\\"cat_stats\\\") and (numcol != \\\"\\\"): numcol = self.parent.format_colnames(numcol)\",\n \"= \\\"{}({})\\\".format(func.upper(), \\\"{}\\\") else: expr = \\\"{}({}, {})\\\".format(func.upper(), \\\"{}\\\", x) return self.apply(func=expr) #\",\n \"value. vDataFrame[].str_slice : Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"pat\\\", pat, [str])]) return self.apply( func=\\\"REGEXP_COUNT({},\",\n \"list, optional List of the vColumns to use to sort the data when\",\n \"for the regular expression in each record of the vColumn. vDataFrame[].str_replace : Replaces\",\n \"simply because of ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix',\",\n \"= ( \\\"MAX({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), \\\"MIN({}) OVER\",\n \"vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns to the input\",\n \"data. h: float, optional Interval width if the vColumn is numerical or of\",\n \"tan : trigonometric tangent tanh : hyperbolic tangent x: int/float, optional If the\",\n \"self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() # ---# def _repr_html_(self):\",\n \"self, by: str = \\\"\\\", h: float = 0, max_cardinality: int = 8,\",\n \"vDataFrame.analytic : Adds a new vColumn to the vDataFrame by using an advanced\",\n \"vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"stddev\\\"]).values[self.alias][0] stddev = std # ---# def store_usage(self):\",\n \"of distinct elements for vColumns 1 and 2 to be used as categorical\",\n \"method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn must be numerical\",\n \"not (\\\"legend\\\" in kwargs): kwargs[\\\"legend\\\"] = True if not (\\\"figsize\\\" in kwargs): kwargs[\\\"figsize\\\"]\",\n \"alias. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.add_copy : Creates a copy\",\n \"self.catalog[\\\"max\\\"] = 1 self.parent.__add_to_history__( \\\"[Normalize]: The vColumn '{}' was normalized with the method\",\n \"= \\\"\\\"\\\"(SELECT {0} || '', COUNT(*) FROM vdf_table GROUP BY {0} ORDER BY\",\n \"vColumn will be transformed. Parameters ---------- pat: str regular expression. Returns ------- vDataFrame\",\n \"= (sauv[elem] - sauv[\\\"min\\\"]) / ( sauv[\\\"max\\\"] - sauv[\\\"min\\\"] ) except: pass if\",\n \"empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already the alias {name}.\\\\nBy\",\n \"You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 #\",\n \"---# def date_part(self, field: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Extracts a specific TS field from\",\n \"parameter is equal to 0, an optimised interval will be computed. nbins: int,\",\n \"binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct() trans = self.discretize( method=\\\"same_width\\\" if self.isnum() else\",\n \"was transformed with the func 'x -> {}'.\\\".format( self.alias.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), )\",\n \"object which that stores all user transformations. If the vDataFrame represents the entire\",\n \"k: int, optional The integer k of the 'topk' method. new_category: str, optional\",\n \"vColumn 'of'. q% : q Quantile of the vColumn 'of' (ex: 50% to\",\n \"AVG({}), STDDEV({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(), by[0], ),\",\n \"self.parent.shape()[0] ) except: pass self.parent.__add_to_history__( \\\"[Discretize]: The vColumn {} was discretized.\\\".format(self.alias) ) return\",\n \"range_curve_vdf( self, ts, q, start_date, end_date, plot_median, ax=ax, **style_kwds, ) # ---# def\",\n \"self.catalog[elem] = None elif method == \\\"robust_zscore\\\": self.catalog[elem] = (sauv[elem] - sauv[\\\"approx_50%\\\"]) /\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self,\",\n \"tree_id = {}, format = 'tabular'))\\\".format( tmp_model_name, i ) for i in range(parameters[\\\"n_estimators\\\"])\",\n \"columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] = sauv[\\\"count\\\"] self.catalog[\\\"percent\\\"] = ( 100\",\n \"{} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize( self,\",\n \"the method '{}'.\\\".format( self.alias, method ) ) else: raise TypeError(\\\"The vColumn must be\",\n \"------- vDataFrame self.parent See Also -------- vDataFrame[].slice : Slices the vColumn using a\",\n \"discretization using the method 'same_freq'\\\" ) count = self.count() nb = int(float(count /\",\n \"input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"using the average of the response partitioned by the different vColumn categories. Parameters\",\n \"\\\".join(by) ), ) if return_trans: return \\\"({} - {}) / {}({} - {})\\\".format(\",\n \"= \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", area: bool = False, step:\",\n \"each of the vColumn records. The vColumn will be transformed. Parameters ---------- pat:\",\n \"else: final_transformation = [ ( \\\"({} - {}) / ({})\\\".format(\\\"{}\\\", med, mad), \\\"float\\\",\",\n \"non_events, events, pt_non_events, pt_events, CASE WHEN non_events = 0 OR events = 0\",\n \"self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the descriptive statistics of {}.\\\".format(self.alias),\",\n \"happened during the filling.\\\".format(e)) if total > 0: try: if \\\"count\\\" in sauv:\",\n \"\\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{}, {}\\\".format( \\\"'{}'\\\".format(str(elem[0]).replace(\\\"'\\\", \\\"''\\\")) if elem[0]\",\n \"aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float], (\\\"approx\\\", approx, [bool]))]) prefix = \\\"approx_\\\" if\",\n \"else \\\"\\\" return self.aggregate(func=[prefix + \\\"{}%\\\".format(x * 100)]).values[self.alias][ 0 ] # ---# def\",\n \"self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin = ( \\\"MAX({}) OVER (PARTITION\",\n \"\\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"of the parent vDataFrame. This parameter is used for testing purpose. Returns -------\",\n \"= \\\"SELECT {}{} FROM {}{} OFFSET {} LIMIT 1\\\".format( self.alias, cast, self.parent.__genSQL__(), self.parent.__get_last_order_by__(),\",\n \"generation will be slower if the vDataFrame has been transformed multiple times, so\",\n \"the vColumn. You can write the following list: [\\\"Fouad\\\", \\\"Badr\\\"] Returns ------- vDataFrame\",\n \"function to the input vColumn. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].apply\",\n \") p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias), method=\\\"fetchrow\\\", )\",\n \"bool, optional If set to True, the record will be sliced using the\",\n \"title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel = kernel.lower() from\",\n \"if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias, by] else: columns =\",\n \"\\\"acos\\\", \\\"asin\\\", \\\"atan\\\", \\\"cbrt\\\", \\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\",\",\n \"vColumn with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding\",\n \"hyperbolic tangent x: int/float, optional If the function has two arguments (example, power\",\n \") max_floor = len(self.parent[response].transformations) - len( self.transformations ) for k in range(max_floor): self.transformations\",\n \"variable in relation to the dependent variable. Parameters ---------- y: str Response vColumn.\",\n \"else: return getattr(self, index) # ---# def __len__(self): return int(self.count()) # ---# def\",\n \"/ std robust_zscore : Normalization using the Robust Z-Score (median and mad). (x\",\n \"< {}) UNION ALL (SELECT AVG({}) FROM vdf_table WHERE {} > {})\\\".format( self.parent.__genSQL__(),\",\n \"+ [item[0] for item in query_result] else: result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias],\",\n \"list List of the different records. For example, to check if Badr and\",\n \"(\\\"expr\\\", expr, [str]), (\\\"by\\\", by, [list]), (\\\"order_by\\\", order_by, [list]), ] ) method =\",\n \"{} IS NOT NULL ORDER BY {} DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias,\",\n \"One-Hot Encoding. \\\"\\\"\\\" check_types([(\\\"response\\\", response, [str])]) self.parent.are_namecols_in(response) response = self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError(\",\n \"Returns ------- bool True if the vColumn is boolean. See Also -------- vDataFrame[].isdate\",\n \"See Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\"\",\n \"by = self.parent.format_colnames(by) nullifzero, n = 1, len(by) if self.isbool(): warning_message = \\\"Normalize\",\n \"float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, -({}), {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} - ({})\\\".format(\\\"{}\\\",\",\n \"USING PARAMETERS percentile = 0.5) AS 'approx_50%', APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile =\",\n \"\\\"\\\"\\\" check_types( [ (\\\"ts\\\", ts, [str]), (\\\"by\\\", by, [str]), (\\\"start_date\\\", start_date, [str, datetime.datetime,\",\n \") return executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self,\",\n \"[ (\\\"method\\\", method, [\\\"auto\\\", \\\"numerical\\\", \\\"categorical\\\", \\\"cat_stats\\\"]), (\\\"max_cardinality\\\", max_cardinality, [int, float]), (\\\"numcol\\\", numcol,\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" check_types([(\\\"x\\\", x, [int, float],\",\n \"impute the vColumn. method: dict, optional Method to use to impute the missing\",\n \"# data around for processing, VerticaPy brings the logic to the data. #\",\n \"Discretizes the vColumn. vDataFrame[].label_encode : Encodes the vColumn with Label Encoding. vDataFrame[].mean_encode :\",\n \"Returns ------- ax Matplotlib axes object See Also -------- vDataFrame[].hist : Draws the\",\n \"will represent the number of seconds, otherwise it will represent a number. Returns\",\n \"[\\\"winsorize\\\", \\\"null\\\", \\\"mean\\\"]), (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int,\",\n \"when 'ts' is greater than November 1993 the 3rd. area: bool, optional If\",\n \"{}, ord, non_events, events, non_events / NULLIFZERO(SUM(non_events) OVER ()) AS pt_non_events, events /\",\n \"stddev = self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not normalize\",\n \"not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0 all_partition = by if method in\",\n \"the vColumns 1 and 2 bars. It is only valid if the vColumns\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"', \\\"\\\")\",\n \"self.transformations = ( parent, alias, [elem for elem in transformations], ) self.catalog =\",\n \"get_dummies( self, prefix: str = \\\"\\\", prefix_sep: str = \\\"_\\\", drop_first: bool =\",\n \"except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1 /\",\n \"function to the vColumn. Parameters ---------- func: str, Function in pure SQL used\",\n \"PARAMETERS percentile = 0.9) AS 'approx_90%', MAX({3}{4}) AS max FROM vdf_table\\\"\\\"\\\".format( category, self.alias,\",\n \"= \\\"Others\\\", RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans: bool =\",\n \"SQL code. Note: Dropping a vColumn can make the vDataFrame \\\"heavier\\\" if it\",\n \"else '\\\"{}{}\\\"'.format( prefix, str(distinct_elements[k]).replace('\\\"', \\\"_\\\") ) ) name = ( name.replace(\\\" \\\", \\\"_\\\")\",\n \"___\\\\ /\\\\ __ \\\\ /\\\\ \\\\ /\\\\ \\\\/\\\\ \\\\ /\\\\ \\\"-./ \\\\ /\\\\\",\n \"int(max(math.floor(h), 1)) floor_end = -1 if (self.category() == \\\"int\\\") else \\\"\\\" if (h\",\n \") ) else: p_alpha, p_1_alpha = ( self.parent.quantile([alpha, 1 - alpha], [self.alias]) .transpose()\",\n \"optional If set to True, draw a Step Plot. ax: Matplotlib axes object,\",\n \"tuple, optional Set the x limits of the current axes. ax: Matplotlib axes\",\n \"... WHEN vColumn = argv[2 * i] THEN argv[2 * i + 1]\",\n \"(PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) else: cmax, cmin = (\",\n \"store usage. \\\"\\\"\\\" pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"store_usage\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\": return pre_comp\",\n \"the absolute value function to the input vColumn. Returns ------- vDataFrame self.parent See\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0] # ---# def cut( self, breaks:\",\n \"-------- vDataFrame.case_when : Creates a new feature by evaluating some conditions. vDataFrame[].discretize :\",\n \"''\\\", \\\"varchar\\\", \\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and\",\n \"+ 2 use \\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not empty,\",\n \") tail.count = self.parent.shape()[0] tail.offset = offset tail.dtype[self.alias] = self.ctype() tail.name = self.alias\",\n \"True, the lowest element of the list will be included. right: bool, optional\",\n \"{}, COUNT(*) AS _verticapy_cnt_ FROM {}{}GROUP BY {} ORDER BY _verticapy_cnt_ DESC LIMIT\",\n \"val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method == \\\"0ifnull\\\": new_column\",\n \"NOT NULL LIMIT 20\\\".format( self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the\",\n \") drop(tmp_model_name, method=\\\"model\\\") if self.parent[response].category() == \\\"float\\\": model = RandomForestRegressor(tmp_model_name) else: model =\",\n \"\\\"POWER({}, 2) + 2\\\". copy_name: str, optional If not empty, a copy will\",\n \"numcol, cast, ) tmp_query += ( \\\" WHERE {} IS NULL\\\".format(self.alias) if (category\",\n \"str, optional Method to use to compute the optimal h. auto : Combination\",\n \"using 'min' (Minimum). Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes\",\n \"upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---# def count(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the\",\n \"title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---#\",\n \"- {}) / {}({} - {})\\\".format( \\\"{}\\\", cmin, \\\"NULLIFZERO\\\" if (nullifzero) else \\\"\\\",\",\n \"statistics of {}.\\\".format(self.alias), method=\\\"fetchall\\\", ) result = [distinct_count, self.count()] + [item[1] for item\",\n \"category will be one of the following: date / int / float /\",\n \"WHERE {} IS NOT NULL LIMIT 0\\\".format( func.replace(\\\"{}\\\", self.alias), self.parent.__genSQL__(), self.alias, ), \\\"apply_test_feature\\\",\",\n \"than the lower bound to the lower bound itself and the values higher\",\n \"result] ), ) executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ),\",\n \"Draws the spider plot of the input vColumn based on an aggregation. Parameters\",\n \"new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj =\",\n \"max_cardinality: int, optional Maximum number of vColumn distinct elements to be used as\",\n \"vColumn using the mean encoding of a response. \\\"\\\"\\\" check_types( [ (\\\"RFmodel_params\\\", RFmodel_params,\",\n \"self.alias for idx in range(len(breaks) - 1): first_elem, second_elem = breaks[idx], breaks[idx +\",\n \"self, method, of, max_cardinality, h, donut, rose, ax=None, **style_kwds, ) # ---# def\",\n \"from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try: parent = self.parent force_columns =\",\n \"\\\"VERTICAPY_NOT_PRECOMPUTED\\\": if not (dropna) and (pre_comp != None): return pre_comp assert n >=\",\n \"new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name] all_new_features += [name] conj = \\\"s were \\\" if\",\n \"for elem in copy_trans] for elem in sauv: self.catalog[elem] = sauv[elem] return self.parent\",\n \"(\\\"prefix\\\", prefix, [str]), (\\\"prefix_sep\\\", prefix_sep, [str]), (\\\"drop_first\\\", drop_first, [bool]), (\\\"use_numbers_as_suffix\\\", use_numbers_as_suffix, [bool]), ]\",\n \"regular expression is in each of the vColumn records. vDataFrame[].extract : Extracts the\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False otherwise. Returns\",\n \"str): \\\"\\\"\\\" --------------------------------------------------------------------------- Adds a copy vColumn to the parent vDataFrame. Parameters ----------\",\n \"pow : number raised to the power of another number round : rounds\",\n \"= \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by) )\",\n \"Matplotlib axes object See Also -------- vDataFrame.donut : Draws the donut chart of\",\n \"unique=False ) .transpose() .values[self.alias] ) count, vColumn_min, vColumn_025, vColumn_075, vColumn_max = ( result[0],\",\n \"License for the specific language governing permissions and # limitations under the License.\",\n \"check = True if len(args) > 0: column = args[0] elif \\\"column\\\" in\",\n \"will return the transformation used instead of the parent vDataFrame. This parameter is\",\n \"= True, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'median'. Parameters ---------- approx:\",\n \"True, the approximate cardinality is returned. By setting this parameter to False, the\",\n \"\\\"SELECT COUNT({}) AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25)\",\n \"pass total = int(total) conj = \\\"s were \\\" if total > 1\",\n \"name, [str])]) name = quote_ident(name.replace('\\\"', \\\"_\\\")) assert name.replace('\\\"', \\\"\\\"), EmptyParameter( \\\"The parameter 'name'\",\n \".replace(\\\"'\\\", \\\"_\\\") ) expr = \\\"DECODE({}, '{}', 1, 0)\\\".format( \\\"{}\\\", str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\") )\",\n \"= self.parent.format_colnames(ts) from verticapy.plot import range_curve_vdf return range_curve_vdf( self, ts, q, start_date, end_date,\",\n \"{}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} smallest elements.\\\".format(n,\",\n \"def isdate(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True if the vColumn category is date, False\",\n \"histogram bins.\\\", method=\\\"fetchall\\\", ) result = [elem[0] for elem in result] elif self.isnum()\",\n \"containing the result. For more information, see utilities.tablesample. See Also -------- vDataFrame[].nsmallest :\",\n \"method when first preparing your data. Parameters ---------- new_name: str The new vColumn\",\n \"# You may not use this file except in compliance with the License.\",\n \"type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts the vColumns\",\n \"-1, k: int = 6, new_category: str = \\\"Others\\\", RFmodel_params: dict = {},\",\n \"NULLIFZERO(SUM(events) OVER ()) AS pt_events FROM ({}) x\\\".format( self.alias, query, ) query =\",\n \"if isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing\",\n \"= 1 / 1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] =\",\n \"is null !\\\".format( self.alias ) warnings.warn(warning_message, Warning) return self elif method == \\\"minmax\\\":\",\n \"will be closed on the right. Returns ------- vDataFrame self.parent See Also --------\",\n \"is date. See Also -------- vDataFrame[].isbool : Returns True if the vColumn is\",\n \"largest vColumn elements. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM\",\n \"self.parent.are_namecols_in(of) of = self.parent.format_colnames(of) from verticapy.plot import pie return pie( self, method, of,\",\n \"were \\\" if len(all_new_features) > 1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]:\",\n \"(median and mad). (x - median) / (1.4826 * mad) minmax : Normalization\",\n \"vDataFrame.applymap : Applies a function to all the vColumns. vDataFrame.eval : Evaluates a\",\n \"previously the method on the vColumn \\\" \\\"or simply because of ambiguous columns\",\n \") warnings.warn(warning_message, Warning) return self elif n == 1: try: result = executeSQL(\",\n \"= \\\"\\\", by: list = [], order_by: list = [], ): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) return self.apply(func=\\\"ROUND({}, {})\\\".format(\\\"{}\\\", n)) # ---# def\",\n \"1 (1 meaning global outlier). \\\"\\\"\\\" if isinstance(method, str): method = method.lower() check_types(\",\n \"index, \\\"value\\\": [self.alias, self.ctype()] + result, } if ((is_date) and not (method ==\",\n \"IS NOT NULL \\\".format(self.alias) if (dropna) else \\\" \\\" result = executeSQL( \\\"SELECT\",\n \"\\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, nbins: int = 0,\",\n \"BY count DESC\\\" ).format(self.alias, max_cardinality + 1) query = \\\"WITH vdf_table AS (SELECT\",\n \"# ---# def label_encode(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn using a bijection from\",\n \"try: query = \\\"SELECT {}::{} AS {} FROM {} WHERE {} IS NOT\",\n \"the method 'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {}\",\n \"of the DB version you are using. Returns ------- tablesample An object containing\",\n \"(\\\"threshold\\\", threshold, [int, float]), ] ) if use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values self.parent.filter(\",\n \"0.75) AS Q3, MAX({}) AS max FROM {}\\\".format( self.alias, self.alias, self.alias, self.alias, self.alias,\",\n \"of two flower brackets {}. For example to apply the function: x ->\",\n \"Slices the vColumn. \\\"\\\"\\\" check_types([(\\\"to_replace\\\", to_replace, [str]), (\\\"value\\\", value, [str])]) return self.apply( func=\\\"REGEXP_REPLACE({},\",\n \"the parameter 'name', you'll be able to solve this issue.\\\" ) new_vColumn =\",\n \"convert to use to convert the vColumn. If this parameter is equal to\",\n \"record is greater than the threshold it will be considered as an outlier.\",\n \"{}) OVER (), PERCENTILE_CONT(1 - {}) WITHIN GROUP (ORDER BY {}) OVER ()\",\n \"Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate(func=[\\\"prod\\\"]).values[self.alias][0] prod = product # ---#\",\n \"Returns ------- str/float/int vColumn nth most occurent element. See Also -------- vDataFrame.aggregate :\",\n \"{}, \\\"regr_sxx\\\": {}, \\\"regr_sxy\\\": {}, \\\"regr_syy\\\": {}, } for elem in catalog: self.catalog[elem]\",\n \"assert not (self.parent.is_colname_in(new_name)), NameError( f\\\"A vColumn has already the alias {new_name}.\\\\nBy changing the\",\n \"): \\\"\\\"\\\" --------------------------------------------------------------------------- Discretizes the vColumn using the input list. Parameters ---------- breaks:\",\n \"the vColumn. Returns ------- list Distinct caterogies of the vColumn. See Also --------\",\n \"-------- vDataFrame.outliers : Computes the vDataFrame Global Outliers. \\\"\\\"\\\" if isinstance(by, str): by\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].date_part : Extracts a specific TS\",\n \"[\\\"total\\\"] result.values[\\\"non_events\\\"] += [sum(result[\\\"non_events\\\"])] result.values[\\\"events\\\"] += [sum(result[\\\"events\\\"])] result.values[\\\"pt_non_events\\\"] += [\\\"\\\"] result.values[\\\"pt_events\\\"] += [\\\"\\\"]\",\n \": Parent of the vColumn. transformations, str : List of the different transformations.\",\n \"\\\\ / / / # \\\\ / / / # \\\\/ / /\",\n \"must be greater or equal to 1\\\") where = \\\" WHERE {} IS\",\n \"= \\\"COALESCE({}, '{}')\\\".format(\\\"{}\\\", val) elif expr: new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", expr) elif method\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(new_column, ctype, category)] try:\",\n \"bool, optional If set to True, the information will be stored in the\",\n \"tail.name = self.alias return tail # ---# def isbool(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns True\",\n \"quantile(1-alpha) if 'use_threshold' is set to False else the lower and upper ZScores.\",\n \") return self.parent one_hot_encode = get_dummies # ---# def head(self, limit: int =\",\n \"\\\"Reads {} {} largest elements.\\\".format(self.alias, n) return to_tablesample(query, title=title) # ---# def normalize(\",\n \"schema = \\\"public\\\" name = gen_tmp_name(schema=schema, name=\\\"kde\\\") if isinstance(xlim, (tuple, list)): xlim_tmp =\",\n \"# speed and built-in analytics and machine learning features. It supports the #\",\n \"How the intervals should be closed. If set to True, the intervals will\",\n \"xmax = xlim custom_lines = [] columns = self.parent[by].distinct() for idx, column in\",\n \"self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\" in sauv: self.catalog[\\\"count\\\"] =\",\n \"self, ts: str, by: str = \\\"\\\", start_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\",\",\n \"-> {}'.\\\".format( copy_name.replace('\\\"', \\\"\\\"), func.replace(\\\"{}\\\", \\\"x\\\"), ) ) else: for k in range(max_floor):\",\n \"== \\\"robust_zscore\\\": if n > 0: warning_message = \\\"The method 'robust_zscore' is available\",\n \"True, alpha: float = 0.05, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Fills the vColumns outliers using\",\n \"[\\\"auto\\\", \\\"donut\\\", \\\"rose\\\"]), ] ) donut = True if pie_type == \\\"donut\\\" else\",\n \"str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: int = 6, nbins: int\",\n \"# / # VerticaPy is a Python library with scikit-like functionality for conducting\",\n \"(elem[1] == None) else str(elem[1]) new_column = \\\"COALESCE({}, DECODE({}, {}, NULL))\\\".format( \\\"{}\\\", by[0],\",\n \"distinct_count, is_numeric, is_date = ( self.nunique(), self.isnum(), self.isdate(), ) if (is_date) and not\",\n \"float = 0, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the bar chart of\",\n \"is set to False else the lower and upper ZScores. threshold: float, optional\",\n \"std : standard deviation topk : kth most occurent element (ex: top1 for\",\n \"to be used as categorical (No h will be picked or computed) nbins:\",\n \"If set to True, the approximate quantile is returned. By setting this parameter\",\n \"self.parent # ---# def dropna(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Filters the vDataFrame where the vColumn\",\n \"{} IS NOT NULL) VERTICAPY_SUBTABLE {}\\\".format( self.alias, self.alias, self.alias, self.parent.__genSQL__(), self.alias, where, )\",\n \") else: query = \\\"SELECT {} FROM (SELECT {} AS {}, {} AS\",\n \"vDataFrame.add_copy : Creates a copy of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name\",\n \": kurtosis jb : Jarque-Bera index mad : median absolute deviation max :\",\n \"on an aggregation. \\\"\\\"\\\" check_types( [ (\\\"by\\\", by, [str]), (\\\"kernel\\\", kernel, [\\\"gaussian\\\", \\\"logistic\\\",\",\n \"data science projects on data stored in Vertica, taking advantage Vertica’s # speed\",\n \"h will be computed. ax: Matplotlib axes object, optional The axes to plot\",\n \"if len(cat) == 1: lp, rp = \\\"(\\\", \\\")\\\" else: lp, rp =\",\n \"NULLIFZERO(pt_events))) END AS woe, CASE WHEN non_events = 0 OR events = 0\",\n \"str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---# def\",\n \"nunique(self, approx: bool = True): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'unique' (cardinality).\",\n \"* FROM {}) {}\\\".format( self.parent.__genSQL__(), query ) query_result = executeSQL( query=query, title=\\\"Computing the\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'mad' (median absolute deviation). Returns ------- float mad\",\n \"round : rounds a value to a specified number of decimal places sign\",\n \"= self.numh() else: h = (self.max() - self.min()) * 1.01 / nbins if\",\n \"will be transformed. Parameters ---------- field: str The field to extract. It must\",\n \"[bool])]) try: parent = self.parent force_columns = [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"]\",\n \"total = self.count() if (method == \\\"mode\\\") and (val == None): val =\",\n \"lower bound itself and the values higher than the upper bound to the\",\n \"query, title=\\\"Different aggregations to compute the optimal h.\\\", method=\\\"fetchrow\\\", ) count, vColumn_min, vColumn_025,\",\n \"self.alias, p_1_alpha, ) mean_alpha, mean_1_alpha = [ item[0] for item in executeSQL( query=query,\",\n \"NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY\",\n \"of the dummies. drop_first: bool, optional Drops the first dummy to avoid the\",\n \"the vColumn. See Also -------- vDataFrame.topk : Returns the vColumn most occurent elements.\",\n \"vColumn. \\\"\\\"\\\" check_types( [ (\\\"breaks\\\", breaks, [list]), (\\\"labels\\\", labels, [list]), (\\\"include_lowest\\\", include_lowest, [bool]),\",\n \"---# def max(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'max' (Maximum). Returns -------\",\n \"\\\\ \\\\_____\\\\ \\\\ \\\\_____\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\ \\\\ \\\\_\\\\\\\\\\\"\\\\_\\\\ # \\\\/_/ \\\\/_____/\",\n \") self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"].remove(self.alias) delattr(self.parent, self.alias) except: self.parent._VERTICAPY_VARIABLES_[\\\"exclude_columns\\\"] += [self.alias] if add_history: self.parent.__add_to_history__( \\\"[Drop]: vColumn\",\n \"(\\\"cat_priority\\\", cat_priority, [list]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) from verticapy.plot\",\n \"to True, NULL values will not be considered during the computation. n: int,\",\n \"str = \\\"density\\\", of: str = \\\"\\\", max_cardinality: Union[int, tuple] = (6, 6),\",\n \"float, int]), ] ) if by: self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) columns = [self.alias,\",\n \"for k in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += [(func, ctype,\",\n \"ParameterError( \\\"Length of parameter 'breaks' must be greater or equal to 2.\\\" )\",\n \"func = \\\"(CASE {}{}ELSE {} END)\\\".format(lower_when, upper_when, \\\"{}\\\") self.apply(func=func) return self.parent # ---#\",\n \"if isinstance(pie_type, str): pie_type = pie_type.lower() check_types( [ (\\\"method\\\", method, [str]), (\\\"of\\\", of,\",\n \"Filters the vDataFrame where the vColumn is missing. Returns ------- vDataFrame self.parent See\",\n \"user-specified rule. Parameters ---------- val: int/float/str, optional Value to use to impute the\",\n \"-------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0] # ---#\",\n \"categories to normalize.\\\", method=\\\"fetchall\\\", ) for i in range(len(result)): if result[i][2] == None:\",\n \"the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query = \\\"SELECT * FROM {}\",\n \"str Name of the copy. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.eval\",\n \"utilities.tablesample. See Also -------- vDataFrame[].nlargest : Returns the n largest vColumn elements. \\\"\\\"\\\"\",\n \"NOT NULL GROUP BY 1 ORDER BY 2 DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER\",\n \"The vColumn '{}' was normalized with the method '{}'.\\\".format( self.alias, method ) )\",\n \"[lp + tmp_query + rp] query = \\\"WITH vdf_table AS (SELECT * FROM\",\n \"Number of elements. density : Percentage of the distribution. mean : Average of\",\n \"---------- k: int, optional Number of most occurent elements to return. Returns -------\",\n \"Applies a function to the vColumn. Parameters ---------- func: str, Function in pure\",\n \"vDataFrame[].isnum : Returns True if the vColumn is numerical. \\\"\\\"\\\" return self.category() ==\",\n \"* FROM {} WHERE {} IS NOT NULL ORDER BY {} DESC LIMIT\",\n \"name of the merging category when using the 'topk' method. RFmodel_params: dict, optional\",\n \"min, APPROXIMATE_PERCENTILE ({3}{4} USING PARAMETERS percentile = 0.1) AS 'approx_10%', APPROXIMATE_PERCENTILE ({3}{4} USING\",\n \"Z-Score (median and mad). (x - median) / (1.4826 * mad) minmax :\",\n \"RFmodel_params: dict = {}, response: str = \\\"\\\", return_enum_trans: bool = False, ):\",\n \"\\\"ceil\\\", \\\"cos\\\", \\\"cosh\\\", \\\"cot\\\", \\\"exp\\\", \\\"floor\\\", \\\"ln\\\", \\\"log\\\", \\\"log10\\\", \\\"mod\\\", \\\"pow\\\", \\\"round\\\", \\\"sign\\\",\",\n \"\\\"\\\"\\\" check_types( [ (\\\"alpha\\\", alpha, [int, float]), (\\\"use_threshold\\\", use_threshold, [bool]), (\\\"threshold\\\", threshold, [int,\",\n \"= self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message = \\\"Can not\",\n \"Maximum number of points to use to evaluate the approximate density function. Increasing\",\n \"if return_trans: return \\\"({} - {}) / ({})\\\".format(self.alias, med, mad) else: final_transformation =\",\n \"= [ column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM\",\n \"_ # \\\\ / _ __|_. _ _ |_) # \\\\/ (/_| |\",\n \"using multiple statistical aggregations: min, max, median, unique... depending on the input method.\",\n \"= \\\"\\\", area: bool = False, step: bool = False, ax=None, **style_kwds, ):\",\n \"self.ctype(), self.category())] self.transformations += [ (\\\"AVG({}) OVER (PARTITION BY {})\\\".format(response, \\\"{}\\\"), \\\"int\\\", \\\"float\\\")\",\n \"n > 0: warning_message = \\\"The method 'robust_zscore' is available only if the\",\n \"(\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] ) start_or_end\",\n \"for the discretization (must be > 1) k: int, optional The integer k\",\n \"by: list, optional vColumns used in the partition. return_trans: bool, optimal If set\",\n \"return self.category() == \\\"date\\\" # ---# def isin(self, val: list, *args): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {} IS NOT NULL\\\".format(self.alias) if\",\n \"but will also increase the time of the learning and scoring phases. xlim:\",\n \"the final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes\",\n \"\\\"MIN({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans: return\",\n \"in range(max_floor): self.transformations += [(\\\"{}\\\", self.ctype(), self.category())] self.transformations += final_transformation sauv = {}\",\n \") executeSQL( \\\"SELECT {} FROM {} LIMIT 1\\\".format( new_column.format(self.alias), self.parent.__genSQL__() ), print_time_sql=False, )\",\n \"and include_lowest: op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l\",\n \"= \\\"SELECT {} FROM (SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_\",\n \"vDataFrame.drop: Drops the input vColumns from the vDataFrame. \\\"\\\"\\\" check_types([(\\\"add_history\\\", add_history, [bool])]) try:\",\n \": arithmetic square root tan : trigonometric tangent tanh : hyperbolic tangent x:\",\n \"self.catalog[\\\"percent\\\"] = 100 self.parent.__add_to_history__( \\\"[Label Encoding]: Label Encoding was applied to the vColumn\",\n \"else: raise TypeError(\\\"The vColumn must be numerical for Normalization\\\") return self.parent # ---#\",\n \"---------- approx: bool, optional If set to True, the approximate cardinality is returned.\",\n \"-------- vDataFrame.apply : Applies functions to the input vColumns. vDataFrame.applymap : Applies a\",\n \"One-Hot Encoding algorithm. Parameters ---------- prefix: str, optional Prefix of the dummies. prefix_sep:\",\n \"silverman : Silverman kernel. nbins: int, optional Maximum number of points to use\",\n \"of the search. See Also -------- vDataFrame.isin : Looks if some specific records\",\n \"[0, n - 1] (n being the vColumn cardinality). Returns ------- vDataFrame self.parent\",\n \"max_floor -= len(self.transformations) if copy_name: self.add_copy(name=copy_name) for k in range(max_floor): self.parent[copy_name].transformations += [\",\n \"self.alias, max_cardinality ) if distinct_count > max_cardinality: query += ( \\\"UNION ALL (SELECT\",\n \"and a limit). Parameters ---------- limit: int, optional Number of elements to display.\",\n \"), title=\\\"Computing the mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result) else\",\n \"cut( self, breaks: list, labels: list = [], include_lowest: bool = True, right:\",\n \"'topk'\\\" ) distinct = self.topk(k).values[\\\"index\\\"] trans = ( \\\"(CASE WHEN {} IN ({})\",\n \"set to True, draw an Area Plot. step: bool, optional If set to\",\n \"_verticapy_cnt_ DESC {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result\",\n \"max_floor = len(self.parent[elem].transformations) max_floor -= len(self.transformations) for k in range(max_floor): self.transformations += [(\\\"{}\\\",\",\n \"percents. Parameters ---------- k: int, optional Number of most occurent elements to return.\",\n \"the parent vDataFrame is modified. Attributes ---------- alias, str : vColumn alias. catalog,\",\n \"as e: raise ConversionError( \\\"{}\\\\nThe vColumn {} can not be converted to {}\\\".format(\",\n \"= to_tablesample( \\\"SELECT {} AS {} FROM {}{} LIMIT {} OFFSET {}\\\".format( bin_spatial_to_str(self.category(),\",\n \"aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self, method:\",\n \"must not be empty\\\" ) assert not (self.parent.is_colname_in(name)), NameError( f\\\"A vColumn has already\",\n \"transformation operations, and offers beautiful graphical options. # # VerticaPy aims to do\",\n \"method. Parameters ---------- method: str, optional The describe method. auto : Sets the\",\n \"mode.\\\", method=\\\"fetchall\\\", ) top = None if not (result) else result[0][0] if not\",\n \"to the vColumn. Parameters ---------- func: str, Function in pure SQL used to\",\n \"0 for elem in by: if len(self.parent[elem].transformations) > max_floor: max_floor = len(self.parent[elem].transformations) max_floor\",\n \"elif self.isnum() and method == \\\"same_freq\\\": assert nbins >= 2, ParameterError( \\\"Parameter 'nbins'\",\n \"will be computed if the parameter is empty or invalid. max_cardinality: int, optional\",\n \"{} > {} THEN {} ELSE {} END)\\\".format( \\\"{}\\\", p_alpha, mean_alpha, \\\"{}\\\", p_1_alpha,\",\n \"\\\"\\\" if (k < 1) else \\\"LIMIT {}\\\".format(k) dropna = \\\" WHERE {}\",\n \"\\\"\\\"\\\" --------------------------------------------------------------------------- Renames the vColumn by dropping the current vColumn and creating a\",\n \"DESC LIMIT {}\\\".format( self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {}\",\n \"else \\\" \\\" result = executeSQL( \\\"SELECT {} FROM (SELECT {}, COUNT(*) AS\",\n \"the vColumn. The aggregations used are the median and two input quantiles. Parameters\",\n \"-------- vDataFrame[].slice : Slices the vColumn using a time series rule. \\\"\\\"\\\" return\",\n \"---------- n: int, optional Offset. Returns ------- tablesample An object containing the result.\",\n \"result = executeSQL( query=query, title=\\\"Computing the equal frequency histogram bins.\\\", method=\\\"fetchall\\\", ) result\",\n \"median absolute deviation max : maximum mean : average median : median min\",\n \"cmin, ), \\\"float\\\", \\\"float\\\", ) ] if method != \\\"robust_zscore\\\": max_floor = 0\",\n \"values: for i in range(len(values[elem])): if isinstance(values[elem][i], decimal.Decimal): values[elem][i] = float(values[elem][i]) return tablesample(values)\",\n \"the threshold, it will be considered as an outlier. use_threshold: bool, optional Uses\",\n \": Returns the vColumn most occurent elements. \\\"\\\"\\\" if \\\"agg\\\" not in kwargs:\",\n \"check_types([(\\\"x\\\", x, [int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return\",\n \"AS ord, {}::int AS {} FROM {}\\\".format( trans, self.alias, self.alias, y, y, self.parent.__genSQL__(),\",\n \"\\\"START\\\" if (start) else \\\"END\\\" return self.apply( func=\\\"TIME_SLICE({}, {}, '{}', '{}')\\\".format( \\\"{}\\\", length,\",\n \"\\\"[Label Encoding]: Label Encoding was applied to the vColumn {} using the following\",\n \"# ---# def std(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'std' (Standard Deviation).\",\n \"method, of, max_cardinality, nbins, h, ax=ax, **style_kwds) # ---# def boxplot( self, by:\",\n \"**style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the Time Series of the vColumn. Parameters ----------\",\n \"= self.parent.format_colnames(by) from verticapy.plot import boxplot return boxplot(self, by, h, max_cardinality, cat_priority, ax=ax,\",\n \"---# def apply(self, func: str, copy_name: str = \\\"\\\"): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a\",\n \"functions. Parameters ---------- func: list List of the different aggregation. aad : average\",\n \"op1, close_l = \\\"<=\\\", \\\"[\\\" elif idx == 0: op1, close_l = \\\"<\\\",\",\n \"memory usage. \\\"\\\"\\\" import sys total = ( sys.getsizeof(self) + sys.getsizeof(self.alias) + sys.getsizeof(self.transformations)\",\n \"= \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple statistical aggregations: min,\",\n \"must be greater or equals to 2 in case of discretization using the\",\n \"self.alias, dtype, self.alias, self.parent.__genSQL__(), self.alias ) executeSQL(query, title=\\\"Testing the Type casting.\\\") self.transformations +=\",\n \"the MIN and the MAX. MAX = MIN !\\\".format( self.alias ) warnings.warn(warning_message, Warning)\",\n \"Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count : Computes the number of\",\n \"information, see utilities.tablesample. See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations.\",\n \"the n smallest elements in the vColumn. \\\"\\\"\\\" check_types([(\\\"n\\\", n, [int, float])]) query\",\n \"at risk dtype : vColumn type iqr : interquartile range kurtosis : kurtosis\",\n \"self.count()] + [item[1] for item in query_result] index = [\\\"unique\\\", \\\"count\\\"] + [item[0]\",\n \"the vColumn. \\\"\\\"\\\" check_types( [ ( \\\"func\\\", func, [ \\\"abs\\\", \\\"acos\\\", \\\"asin\\\", \\\"atan\\\",\",\n \"the vColumn outliers using the input method. \\\"\\\"\\\" check_types([(\\\"lower\\\", lower, [float, int]), (\\\"upper\\\",\",\n \"] ) method = method.lower() self.parent.are_namecols_in(by) by = self.parent.format_colnames(by) nullifzero, n = 1,\",\n \"column for column in self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] ] force_columns.remove(self.alias) executeSQL( \\\"SELECT * FROM {} LIMIT\",\n \"func: list): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using the input functions. Parameters ----------\",\n \"of bins will be computed. h: float, optional Interval width of the bar.\",\n \"int, optional Number of nbins. If empty, an optimized number of nbins will\",\n \") except: pass if method == \\\"robust_zscore\\\": self.catalog[\\\"median\\\"] = 0 self.catalog[\\\"mad\\\"] = 1\",\n \"Also -------- vDataFrame.astype : Converts the vColumns to the input type. \\\"\\\"\\\" check_types([(\\\"dtype\\\",\",\n \"computation. n: int, optional Integer corresponding to the offset. For example, if n\",\n \"encoder was applied to the vColumn {}\\\\n{} feature{}created: {}\\\".format( self.alias, len(all_new_features), conj, \\\",\",\n \"elem[0] != None else \\\"NULL\\\", elem[1] if elem[1] != None else \\\"NULL\\\", )\",\n \"if the regular expression is in each of the vColumn records. vDataFrame[].extract :\",\n \"isinstance(index, slice): assert index.step in (1, None), ValueError( \\\"vColumn doesn't allow slicing having\",\n \"(int(sauv[\\\"count\\\"]) + total) / self.parent.shape()[0] ) except: pass total = int(total) conj =\",\n \"self.alias, self.parent.__genSQL__() ) p_alpha, p_1_alpha = executeSQL( query=query, title=\\\"Computing the quantiles of {}.\\\".format(self.alias),\",\n \"datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\", plot_median, [bool]), ] ) self.parent.are_namecols_in(ts) ts =\",\n \"def __nonzero__(self): return self.count() > 0 # ---# def __repr__(self): return self.head(limit=verticapy.options[\\\"max_rows\\\"]).__repr__() #\",\n \"Also -------- vDataFrame[].drop_outliers : Drops outliers in the vColumn. vDataFrame.outliers : Adds a\",\n \"[ (\\\"length\\\", length, [int, float]), (\\\"unit\\\", unit, [str]), (\\\"start\\\", start, [bool]), ] )\",\n \"), method=\\\"fetchall\\\", ) ] if mean_alpha == None: mean_alpha = \\\"NULL\\\" if mean_1_alpha\",\n \"the different vColumn categories. Parameters ---------- response: str Response vColumn. Returns ------- vDataFrame\",\n \"self.parent, columns, method, of, max_cardinality, h, ax=ax, **style_kwds, ) # ---# def std(self):\",\n \"(count) ** (1.0 / 3.0), 1e-99) if method.lower() == \\\"sturges\\\": best_h = sturges\",\n \"Density Plot. Parameters ---------- by: str, optional vColumn to use to partition the\",\n \"The describe method. auto : Sets the method to 'numerical' if the vColumn\",\n \"vColumn using the input method. Parameters ---------- method: str, optional The method to\",\n \"(self.max() - self.min()) * 1.01 / nbins if h > 0.01: h =\",\n \"use_threshold: result = self.aggregate(func=[\\\"std\\\", \\\"avg\\\"]).transpose().values p_alpha, p_1_alpha = ( -threshold * result[\\\"std\\\"][0] +\",\n \"\\\"::int\\\" if (self.parent[numcol].isbool()) else \\\"\\\" query, cat = [], self.distinct() if len(cat) ==\",\n \"Badr and Fouad are in the vColumn. You can write the following list:\",\n \"NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias, self.alias,\",\n \"quantile is returned. By setting this parameter to False, the function's performance can\",\n \"pat: str Regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_count :\",\n \"input method. Parameters ---------- method: str, optional Method to use to normalize. zscore\",\n \"( parent, alias, [elem for elem in transformations], ) self.catalog = { \\\"cov\\\":\",\n \"use to compute the aggregation. max_cardinality: int, optional Maximum number of the vColumn\",\n \"by if method in [\\\"ffill\\\", \\\"pad\\\", \\\"bfill\\\", \\\"backfill\\\"]: all_partition += [elem for elem\",\n \"mad *= 1.4826 if mad != 0: if return_trans: return \\\"({} - {})\",\n \"end_date: Union[str, datetime.datetime, datetime.date] = \\\"\\\", plot_median: bool = False, ax=None, **style_kwds, ):\",\n \"[int, float])]) return self.apply(func=\\\"SUBSTR({}, {}, {})\\\".format(\\\"{}\\\", start, step)) # ---# def sub(self, x:\",\n \"str = \\\"\\\", max_cardinality: int = 6, h: float = 0, pie_type: str\",\n \"usage. Returns ------- float vColumn memory usage (byte) See Also -------- vDataFrame.memory_usage :\",\n \"one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be able to solve this\",\n \"type numeric|date\\\" ) if self.isnum(): result = ( self.parent.describe( method=\\\"numerical\\\", columns=[self.alias], unique=False )\",\n \"200, xlim: tuple = None, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the vColumn\",\n \"that represents the quantile. For example: 0.25 represents Q1. approx: bool, optional If\",\n \"new categories. If empty, names will be generated. include_lowest: bool, optional If set\",\n \"> 0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\" ---------------------------------------------------------------------------\",\n \"+ 2)), 1e-99, ) fd = max(2.0 * (vColumn_075 - vColumn_025) / (count)\",\n \"), method=\\\"fetchall\\\", ) cmin = \\\"DECODE({}, {}, NULL)\\\".format( by[0], \\\", \\\".join( [ \\\"{},\",\n \"Normalization using the Z-Score (avg and std). (x - avg) / std robust_zscore\",\n \"1.4826 elif method == \\\"zscore\\\": self.catalog[\\\"mean\\\"] = 0 self.catalog[\\\"std\\\"] = 1 elif method\",\n \"of the kernel. kernel: str, optional The method used for the plot. gaussian\",\n \"using 'aad' (Average Absolute Deviation). Returns ------- float aad See Also -------- vDataFrame.aggregate\",\n \"Aggregates the vColumn using 'unique' (cardinality). Parameters ---------- approx: bool, optional If set\",\n \"the input method. Parameters ---------- method: str, optional Method to use to normalize.\",\n \"\\\"SELECT {}, MIN({}), MAX({}) FROM {} GROUP BY {}\\\".format( by[0], self.alias, self.alias, self.parent.__genSQL__(),\",\n \"input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"avg\\\"]).values[self.alias][0] mean = avg # ---# def bar( self,\",\n \"version you are using. Returns ------- tablesample An object containing the result. For\",\n \"True, the information will be stored in the vDataFrame history. Returns ------- vDataFrame\",\n \"Returns ------- float/str minimum See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"0 cmin, cmax = self.aggregate([\\\"min\\\", \\\"max\\\"]).values[self.alias] if cmax - cmin == 0: warning_message\",\n \"), \\\"STDDEV({}) OVER (PARTITION BY {})\\\".format( self.alias, \\\", \\\".join(by) ), ) if return_trans:\",\n \"for elem in transformations], ) self.catalog = { \\\"cov\\\": {}, \\\"pearson\\\": {}, \\\"spearman\\\":\",\n \"ParameterError( \\\"At least 'lower' or 'upper' must have a numerical value\\\" ) lower_when\",\n \"fun == \\\"MEDIAN\\\": val = self.median() new_column = \\\"COALESCE({}, {})\\\".format(\\\"{}\\\", val) elif (len(by)\",\n \"to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\") # ---# def add(self, x: float):\",\n \"---# def apply_fun(self, func: str, x: float = 2): \\\"\\\"\\\" --------------------------------------------------------------------------- Applies a\",\n \"the Random Forest on a response column to find the most relevant interval\",\n \"bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.shape()[0], self.parent.__genSQL__(), dropna, self.alias, topk, ) result = executeSQL( query,\",\n \"executeSQL( query=query, title=\\\"Getting the vColumn element.\\\", method=\\\"fetchfirstelem\\\", ) else: return getattr(self, index) #\",\n \"if return_enum_trans: return trans else: self.transformations += [trans] sauv = {} for elem\",\n \"and Sturges. freedman_diaconis : Freedman Diaconis [2 * IQR / n ** (1\",\n \"if result[i][2] == None: pass elif math.isnan(result[i][2]): result[i][2] = None avg = \\\"DECODE({},\",\n \"if index < 0: index += self.parent.shape()[0] query = \\\"SELECT {}{} FROM {}{}\",\n \"else prefix.replace('\\\"', \\\"_\\\") + prefix_sep.replace('\\\"', \\\"_\\\") ) n = 1 if drop_first else\",\n \"not xlim: xmin = self.min() xmax = self.max() else: xmin, xmax = xlim\",\n \"{ \\\"index\\\": [item[0] for item in result], \\\"count\\\": [int(item[1]) for item in result],\",\n \"y, y, query, ) query = \\\"SELECT {}, ord, non_events, events, non_events /\",\n \"typing import Union # VerticaPy Modules import verticapy from verticapy.utilities import * from\",\n \"str New type. Returns ------- vDataFrame self.parent See Also -------- vDataFrame.astype : Converts\",\n \"the method 'smart'.\\\" ) assert response, ParameterError( \\\"Parameter 'response' can not be empty\",\n \"result[3], result[4], result[6], result[7], ) elif self.isdate(): min_date = self.min() table = \\\"(SELECT\",\n \"\\\"method\\\", method, [\\\"auto\\\", \\\"smart\\\", \\\"same_width\\\", \\\"same_freq\\\", \\\"topk\\\"], ), (\\\"return_enum_trans\\\", return_enum_trans, [bool]), ] )\",\n \": base 10 logarithm mod : remainder of a division operation pow :\",\n \"len(all_new_features), conj, \\\", \\\".join(all_new_features) ) + \\\".\\\" ) return self.parent one_hot_encode = get_dummies\",\n \"be one of the following: CENTURY / DAY / DECADE / DOQ /\",\n \"ctype, category)] self.parent.__update_catalog__(erase=True, columns=[self.alias]) self.parent.__add_to_history__( \\\"[Apply]: The vColumn '{}' was transformed with the\",\n \"self.alias, query, ) query = \\\"SELECT {} AS index, non_events, events, pt_non_events, pt_events,\",\n \"ambiguous columns naming.\\\\nBy changing one of \\\" \\\"the parameters ('prefix', 'prefix_sep'), you'll be\",\n \"final transformation. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].decode : Encodes the\",\n \"aggregation. Parameters ---------- by: str, optional vColumn to use to partition the data.\",\n \"[sum(result[\\\"iv\\\"])] return result # ---# def kurtosis(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using\",\n \"float(values[elem][i]) return tablesample(values) # ---# def discretize( self, method: str = \\\"auto\\\", h:\",\n \"[str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area, [bool]), (\\\"step\\\", step,\",\n \"{column} {op2} '{second_elem}' THEN '{label}'\\\" ] expr = \\\"CASE WHEN \\\" + \\\"\",\n \"ValueError( \\\"vColumn doesn't allow slicing having steps different than 1.\\\" ) index_stop =\",\n \"= self.aggregate([\\\"avg\\\", \\\"std\\\"]).values[self.alias] if stddev == 0: warning_message = \\\"Can not normalize {}\",\n \") ) return self.parent except Exception as e: raise QueryError( \\\"{}\\\\nError when applying\",\n \"NOT NULL GROUP BY {} ORDER BY {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.alias, self.parent.__genSQL__(), self.alias,\",\n \"# ---# def spider( self, by: str = \\\"\\\", method: str = \\\"density\\\",\",\n \"bool True if the vColumn is numerical. See Also -------- vDataFrame[].isbool : Returns\",\n \"BY _verticapy_cnt_ DESC LIMIT {}) VERTICAPY_SUBTABLE ORDER BY _verticapy_cnt_ ASC LIMIT 1\\\".format( self.alias,\",\n \"# |______ / / / # |____/ / / # _____________ / /\",\n \"Also -------- vDataFrame[].hist : Draws the histogram of the vColumn based on an\",\n \"ax.set_title(\\\"KernelDensity\\\") ax.legend( custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax\",\n \"AS NAs, MIN({}) AS min, APPROXIMATE_PERCENTILE({} USING PARAMETERS percentile = 0.25) AS Q1,\",\n \"custom_lines, columns, title=by, loc=\\\"center left\\\", bbox_to_anchor=[1, 0.5], ) ax.set_xlabel(self.alias) return ax kernel =\",\n \"that relation. vColumns simplify several processes with its abstractions. Parameters ---------- alias: str\",\n \"if return_trans: return \\\"({} - {}) / {}({} - {})\\\".format( self.alias, cmin, \\\"NULLIFZERO\\\"\",\n \"The vColumn will be transformed. Parameters ---------- start: int Start of the slicing.\",\n \"\\\"median\\\"): fun = \\\"MEDIAN\\\" if (method == \\\"median\\\") else \\\"AVG\\\" if by ==\",\n \"check_types( [ (\\\"by\\\", by, [str]), (\\\"method\\\", method, [str]), (\\\"of\\\", of, [str]), (\\\"max_cardinality\\\", max_cardinality,\",\n \"\\\"spearman\\\": {}, \\\"spearmand\\\": {}, \\\"kendall\\\": {}, \\\"cramer\\\": {}, \\\"biserial\\\": {}, \\\"regr_avgx\\\": {}, \\\"regr_avgy\\\":\",\n \"(SELECT {}, ROW_NUMBER() OVER (ORDER BY {}) AS _verticapy_row_nb_ FROM {} WHERE {}\",\n \"------- str vColumn DB type. \\\"\\\"\\\" return self.transformations[-1][1].lower() dtype = ctype # ---#\",\n \"0\\\".format(\\\"{}\\\", pat.replace(\\\"'\\\", \\\"''\\\")) ) # ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes\",\n \"the parameter is empty or invalid. max_cardinality: int, optional Maximum number of vColumn\",\n \"element percent : percent of non-missing elements q% : q quantile (ex: 50%\",\n \"return self.parent[columns].to_geopandas(self.alias).plot(*args, **kwargs) # ---# def get_dummies( self, prefix: str = \\\"\\\", prefix_sep:\",\n \"computed) nbins: int, optional Number of bins. If empty, an optimized number of\",\n \"# ---# def str_count(self, pat: str): \\\"\\\"\\\" --------------------------------------------------------------------------- Computes the number of matches\",\n \"self.transformations] total = self.count() if method not in [\\\"mode\\\", \\\"0ifnull\\\"]: max_floor = 0\",\n \"the func 'x -> {}' to '{}'\\\".format( e, func.replace(\\\"{}\\\", \\\"x\\\"), self.alias.replace('\\\"', \\\"\\\") )\",\n \"self.alias, ), \\\"apply_test_feature\\\", ) category = get_category_from_vertica_type(ctype=ctype) all_cols, max_floor = self.parent.get_columns(), 0 for\",\n \"response column must be numerical to use a mean encoding\\\" ) max_floor =\",\n \"have multiple children vColumns whereas one vColumn can only have one parent. catalog:\",\n \"(most occurent element). 0ifnull : 0 when the vColumn is null, 1 otherwise.\",\n \"__ __ ______ ______ __ __ __ __ __ __ __ # /\\\\\",\n \"ctype, category)] try: sauv = {} for elem in self.catalog: sauv[elem] = self.catalog[elem]\",\n \"Fills the outliers in the vColumn. vDataFrame.outliers : Adds a new vColumn labeled\",\n \"Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of a\",\n \"[0, 1], TypeError( \\\"vColumn {} must be binary to use iv_woe.\\\".format(y) ) self.parent[y].distinct()\",\n \"0.25 represents Q1. approx: bool, optional If set to True, the approximate quantile\",\n \"== \\\"int\\\") else \\\"\\\" if (h > 1) or (self.category() == \\\"float\\\"): trans\",\n \"self.parent.__genSQL__(), self.alias, self.alias, n ) title = \\\"Reads {} {} largest elements.\\\".format(self.alias, n)\",\n \"= fd else: best_h = max(sturges, fd) self.parent.__update_catalog__({\\\"index\\\": [\\\"numh\\\"], self.alias: [best_h]}) if self.category()\",\n \"[list]), (\\\"order_by\\\", order_by, [list]), ] ) method = method.lower() self.parent.are_namecols_in([elem for elem in\",\n \"the function's performance can drastically decrease. Returns ------- float quantile (or approximate quantile).\",\n \"0, }, ) setattr(self.parent, name, new_vColumn) setattr(self.parent, name.replace('\\\"', \\\"\\\"), new_vColumn) self.parent._VERTICAPY_VARIABLES_[\\\"columns\\\"] += [name]\",\n \"\\\"float\\\" else \\\"\\\" if index < 0: index += self.parent.shape()[0] query = \\\"SELECT\",\n \") query_result = executeSQL( query=query, title=\\\"Computing the distinct categories of {}.\\\".format(self.alias), method=\\\"fetchall\\\", )\",\n \"or computed) nbins: int, optional Number of nbins. If empty, an optimized number\",\n \"Also -------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" return\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"sum\\\"]).values[self.alias][0]\",\n \"--------------------------------------------------------------------------- Aggregates the vColumn using 'var' (Variance). Returns ------- float var See Also\",\n \"[int, float])]) if self.isdate(): return self.apply(func=\\\"TIMESTAMPADD(SECOND, {}, {})\\\".format(x, \\\"{}\\\")) else: return self.apply(func=\\\"{} +\",\n \"setting this parameter to False, the function's performance can drastically decrease. Returns -------\",\n \"---# def sem(self): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using 'sem' (standard error of\",\n \"head(self, limit: int = 5): \\\"\\\"\\\" --------------------------------------------------------------------------- Returns the head of the vColumn.\",\n \"of the vColumn. \\\"\\\"\\\" check_types([(\\\"new_name\\\", new_name, [str])]) old_name = quote_ident(self.alias) new_name = new_name.replace('\\\"',\",\n \"method.lower() if method == \\\"auto\\\": pre_comp = self.parent.__get_catalog_value__(self.alias, \\\"numh\\\") if pre_comp != \\\"VERTICAPY_NOT_PRECOMPUTED\\\":\",\n \"vDataFrame self.parent See Also -------- vDataFrame[].apply : Applies a function to the input\",\n \"Number of most occurent elements to return. dropna: bool, optional If set to\",\n \"\\\"round\\\", \\\"sign\\\", \\\"sin\\\", \\\"sinh\\\", \\\"sqrt\\\", \\\"tan\\\", \\\"tanh\\\", ], ), (\\\"x\\\", x, [int, float]),\",\n \"-------- vDataFrame[].apply : Applies a function to the input vColumn. \\\"\\\"\\\" return self.apply(func=\\\"ABS({})\\\")\",\n \"{}\\\".format(str(distinct_elements[k]).replace(\\\"'\\\", \\\"''\\\"), k) ] text_info += \\\"\\\\t{} => {}\\\".format(distinct_elements[k], k) expr = \\\",\",\n \"vColumns. Parameters ---------- add_history: bool, optional If set to True, the information will\",\n \"Returns ------- float average See Also -------- vDataFrame.aggregate : Computes the vDataFrame input\",\n \"other vColumns. Parameters ---------- add_history: bool, optional If set to True, the information\",\n \"dummies. drop_first: bool, optional Drops the first dummy to avoid the creation of\",\n \"\\\"''\\\") ) transformations = self.transformations + [(expr, \\\"bool\\\", \\\"int\\\")] new_vColumn = vColumn( name,\",\n \"__ ______ ______ __ __ __ __ __ __ __ # /\\\\ \\\\\",\n \"table ) result = executeSQL( query, title=\\\"Different aggregations to compute the optimal h.\\\",\",\n \"[str]), (\\\"start_date\\\", start_date, [str, datetime.datetime, datetime.date]), (\\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date]), (\\\"area\\\", area,\",\n \"aad : average absolute deviation approx_unique : approximative cardinality count : number of\",\n \"or equals to 2 in case of discretization using the method 'same_freq'\\\" )\",\n \"int, float], ), ( \\\"end_date\\\", end_date, [str, datetime.datetime, datetime.date, int, float], ), (\\\"plot_median\\\",\",\n \"See Also -------- vDataFrame.aggregate : Computes the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"count\\\"]).values[self.alias][0]\",\n \"0 for k in range(len(distinct_elements) - n): name = ( '\\\"{}{}\\\"'.format(prefix, k) if\",\n \"bool = False, ax=None, **style_kwds, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Draws the range plot of\",\n \"1 else \\\" was \\\" self.parent.__add_to_history__( \\\"[Get Dummies]: One hot encoder was applied\",\n \"bool = False, ): \\\"\\\"\\\" --------------------------------------------------------------------------- Encodes the vColumn with the One-Hot Encoding\",\n \"pat: str regular expression. Returns ------- vDataFrame self.parent See Also -------- vDataFrame[].str_contains :\",\n \"max(2.0 * (vColumn_075 - vColumn_025) / (count) ** (1.0 / 3.0), 1e-99) if\",\n \"with Label Encoding. vDataFrame[].mean_encode : Encodes the vColumn using the mean encoding of\",\n \"= self.parent.format_colnames(response) assert self.parent[response].isnum(), TypeError( \\\"The response column must be numerical to use\",\n \"6, numcol: str = \\\"\\\" ): \\\"\\\"\\\" --------------------------------------------------------------------------- Aggregates the vColumn using multiple\",\n \"\\\"text\\\") if (self.isnum() and method == \\\"same_freq\\\") or ( self.isnum() and method ==\",\n \"optional vColumns used in the partition. order_by: list, optional List of the vColumns\",\n \"self.parent.__genSQL__(), self.parent.__get_last_order_by__(), index_start, limit, ) return vDataFrameSQL(query) elif isinstance(index, int): cast = \\\"::float\\\"\",\n \"ZEROIFNULL(SUM(LENGTH({}::varchar))) FROM {}\\\".format( bin_spatial_to_str(self.category(), self.alias), self.parent.__genSQL__(), ), title=\\\"Computing the Store Usage of the\",\n \"[name] self.parent.__add_to_history__( \\\"[Add Copy]: A copy of the vColumn {} named {} was\",\n \"at least one element to use to order the data\\\" ) desc =\",\n \"(\\\"mean\\\", \\\"median\\\") or isinstance(val, float): category, ctype = \\\"float\\\", \\\"float\\\" elif method ==\",\n \"log10 : base 10 logarithm mod : remainder of a division operation pow\",\n \"{} for elem in self.catalog: sauv[elem] = self.catalog[elem] self.parent.__update_catalog__(erase=True, columns=[self.alias]) try: if \\\"count\\\"\",\n \"the vDataFrame input aggregations. \\\"\\\"\\\" return self.aggregate([\\\"skewness\\\"]).values[self.alias][0] skew = skewness # ---# def\",\n \"new_column = \\\"COALESCE({}, {}({}) OVER (PARTITION BY {}))\\\".format( \\\"{}\\\", fun, \\\"{}\\\", \\\", \\\".join(by)\"\n]","isConversational":false}}},{"rowIdx":2498,"cells":{"ngram":{"kind":"list like","value":["= book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET',","from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request","render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" # # :param","col name # :param order: asc or desc # :return: renew query #","index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta","id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put","get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\"","return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post","import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import","'POST']) # def list_book(): # \"\"\" # # :param field: col name #","BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data","form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data",".forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain","form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data","book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year","@book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow","a date formatted equal to how it is presented # in the table","ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose query =","= form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note =","booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp)","form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data","been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__': pass","return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" # #","will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login",">= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration,","from datatables import ColumnDT, DataTables from .. import auth from .. import db","what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return","# the current directory is changed with os.chdir(), an incorrect # path will","for the query and table needed rowTable = DataTables(params, query, columns) # returns","methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book data :param id: :return:","EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title","# will search a date formatted equal to how it is presented #","book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year","__file__ attribute on a module is a relative path and # the current",":return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn =","render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining columns","'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int)","from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) #","temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has","form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data","flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data","Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't be fixed here: #","query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/',","= get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has been","{id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta","db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id","BSD-3-Clause \"\"\" # Known bugs that can't be fixed here: # - synopsis()","purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a","book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link","form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data","book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint","= book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data =","from flask_login import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy","def get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book():","string, so string searching the date # will search a date formatted equal","book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book)",":param order: asc or desc # :return: renew query # \"\"\" # books","= book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data =","flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't","del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\"","type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination)","hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit():","= pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\"","1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" #","that can't be fixed here: # - synopsis() cannot be prevented from clobbering","= BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'],","print(temp) form.body.data = temp # flash('Your book data has been updated.', 'success') #","added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST'])","\"\"\" example.py ~~~~~~~~~ A simple command line application to run flask apps. :copyright:","= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.',","EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # ---------------------------------------------------------","how it is presented # in the table columns = [ # ColumnDT(cast(BookMain.id,","ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint),","page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books","ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite)","# ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial","or desc # :return: renew query # \"\"\" # books = BookMain.get_all_book() #","form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data",":return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id =","def edit_book(id): \"\"\" edit , put book data :param id: :return: \"\"\" form","form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data","@book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" # # :param field: col","cannot be prevented from clobbering existing # loaded modules. # - If the","with os.chdir(), an incorrect # path will be displayed. from flask import render_template,","redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title","ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose","the initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters","request.args.to_dict() # instantiating a DataTable for the query and table needed rowTable =","# :param field: col name # :param order: asc or desc # :return:","form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data","= str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data","\"\"\" # # :param field: col name # :param order: asc or desc",":param field: col name # :param order: asc or desc # :return: renew","# ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending","form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>',","booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def","form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =","logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression","= form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link =","\"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn","@book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book data :param id:",":param id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): #","if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title","render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data',","= form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info =","= form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint =","routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning(","from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from","return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining","db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data =","'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response","in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title),","import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries():","data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form)","\"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data)","columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year),","def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta():","auth from .. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels","query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query","depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict()",":return: renew query # \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\")","users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return","parameters params = request.args.to_dict() # instantiating a DataTable for the query and table","import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user","= query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/',","module is a relative path and # the current directory is changed with","methods=['GET', 'POST']) def get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST'])","= int(book[-1].id) + 1 print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit():","sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import auth from","defining columns # - explicitly cast date to string, so string searching the","A simple command line application to run flask apps. :copyright: 2019 Miller :license:","with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server","book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book","book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return","return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del","# return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return","DataTables(params, query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>',","path and # the current directory is changed with os.chdir(), an incorrect #","existing # loaded modules. # - If the __file__ attribute on a module","after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters:","# ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining","\"\"\" edit , put book data :param id: :return: \"\"\" form = EditBookForm()","asc or desc # :return: renew query # \"\"\" # books = BookMain.get_all_book()","methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1,","DataTable for the query and table needed rowTable = DataTables(params, query, columns) #","# - synopsis() cannot be prevented from clobbering existing # loaded modules. #","needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book","will search a date formatted equal to how it is presented # in","= EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data","'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def","has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>',","{id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short","from .. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import","book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note","displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user,","cast from datatables import ColumnDT, DataTables from .. import auth from .. import","string searching the date # will search a date formatted equal to how","needed rowTable = DataTables(params, query, columns) # returns what is needed by DataTable","has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__':","+ 1 print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id =","equal to how it is presented # in the table columns = [","= BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short =","from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import auth","it is presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)),","formatted equal to how it is presented # in the table columns =","and # the current directory is changed with os.chdir(), an incorrect # path","is presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id),","DataTables from .. import auth from .. import db from .forms import EditBookForm,","book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return","booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in","books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): #","# books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with","request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import","book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data =","synopsis() cannot be prevented from clobbering existing # loaded modules. # - If","book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed","get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is :","books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate(","ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on","form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return","returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book():","bugs that can't be fixed here: # - synopsis() cannot be prevented from","updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short","booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn",":copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't be fixed","from clobbering existing # loaded modules. # - If the __file__ attribute on","form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data","= [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info)","an incorrect # path will be displayed. from flask import render_template, redirect, request,","book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note","= form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue =","{booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data","-*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line application to","date # will search a date formatted equal to how it is presented","= BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <=","- synopsis() cannot be prevented from clobbering existing # loaded modules. # -","@book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page',","to how it is presented # in the table columns = [ #","book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite","%s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST'])","so string searching the date # will search a date formatted equal to","% (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): #","'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data","query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query","# print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp","import auth from .. import db from .forms import EditBookForm, HackmdMeta # from","import ColumnDT, DataTables from .. import auth from .. import db from .forms","= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index'))","book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue","query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext:","data :param id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit():","be fixed here: # - synopsis() cannot be prevented from clobbering existing #","table needed rowTable = DataTables(params, query, columns) # returns what is needed by","db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data =","import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from ..","form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit","edit_book(id): \"\"\" edit , put book data :param id: :return: \"\"\" form =","id = int(book[-1].id) + 1 print(f\"id is : {id}\") form = EditBookForm() if","is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your","query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable","data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ ==","login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import","= book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data =","import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain #","def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if","be prevented from clobbering existing # loaded modules. # - If the __file__","put book data :param id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404()","# def list_book(): # \"\"\" # # :param field: col name # :param","import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries","@book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining columns #","= EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn =","from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user,","presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn),","utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line application to run flask","been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET',","modules. # - If the __file__ attribute on a module is a relative","'POST']) def edit_book(id): \"\"\" edit , put book data :param id: :return: \"\"\"","import cast from datatables import ColumnDT, DataTables from .. import auth from ..","book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT,","post_book(): \"\"\" post new book entry :return: \"\"\" book = BookMain.query.all() id =","book data :param id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if","new book entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1","- explicitly cast date to string, so string searching the date # will","pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" #","= book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data =","renew query # \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def","per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def","'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta()","form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn","ColumnDT, DataTables from .. import auth from .. import db from .forms import","attribute on a module is a relative path and # the current directory","the current directory is changed with os.chdir(), an incorrect # path will be","run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that","book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book","\"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is : {id}\")","temp # flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return","form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success')","del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import","book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint","\"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users","GET parameters params = request.args.to_dict() # instantiating a DataTable for the query and","# ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your","# @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \"\"\" # # :param field:","current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return","defining the initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET","# books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id,","= request.args.to_dict() # instantiating a DataTable for the query and table needed rowTable","directory is changed with os.chdir(), an incorrect # path will be displayed. from","= BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is : {id}\") form =","def data(): \"\"\"Return server side data.\"\"\" # defining columns # - explicitly cast","date to string, so string searching the date # will search a date","# :return: renew query # \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books)","columns # - explicitly cast date to string, so string searching the date","= DataTables(params, query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result())","flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if","query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters,","db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable for the","# in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short),","rowTable = DataTables(params, query, columns) # returns what is needed by DataTable return","form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) #","HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp =","is a relative path and # the current directory is changed with os.chdir(),","render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del {id}\"","render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book data","fixed here: # - synopsis() cannot be prevented from clobbering existing # loaded","login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from","book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index:","get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import","# flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form)","# book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data","DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side","get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' %",":return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is :","ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed),","book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue","Known bugs that can't be fixed here: # - synopsis() cannot be prevented","if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =","# -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line application","db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note),","return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data =","@book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET',","%s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index():","is changed with os.chdir(), an incorrect # path will be displayed. from flask","ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), #","index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry","return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return:","= db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable for","methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form =","form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data","books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables","f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\"","@book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from booktags.vendor.hackmd_meta import get_hackmdmeta form",".. import auth from .. import db from .forms import EditBookForm, HackmdMeta #","book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is : {id}\") form","# defining the initial query depending on your purpose query = db.session.query().select_from(BookMain) #","common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']:","= book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data =","form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\")","= book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data =","if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn)","import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response):","# # :param field: col name # :param order: asc or desc #","on a module is a relative path and # the current directory is","form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short =","<reponame>MagicSword/Booktags #!/usr/bin/env python3 # -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple","= book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id):","str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data =","clobbering existing # loaded modules. # - If the __file__ attribute on a","ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query","DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index :","def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query:","BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is : {id}\") form = EditBookForm()","\"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data():","form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data","and table needed rowTable = DataTables(params, query, columns) # returns what is needed","command line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\"","list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def","is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello","{id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry :return: \"\"\"",". import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables","def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST'])",":license: BSD-3-Clause \"\"\" # Known bugs that can't be fixed here: # -","redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\"","book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html',","form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data","# loaded modules. # - If the __file__ attribute on a module is","book entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id","BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False)",": {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book","\"\"\"Return server side data.\"\"\" # defining columns # - explicitly cast date to","f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new","query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET',","book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter",", put book data :param id: :return: \"\"\" form = EditBookForm() book =","to string, so string searching the date # will search a date formatted","# Known bugs that can't be fixed here: # - synopsis() cannot be","is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn =","def list_book(): # \"\"\" # # :param field: col name # :param order:","print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn","methods=['GET', 'POST']) # def list_book(): # \"\"\" # # :param field: col name","id: :return: \"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id","# - If the __file__ attribute on a module is a relative path","current directory is changed with os.chdir(), an incorrect # path will be displayed.","current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast","the date # will search a date formatted equal to how it is","] # defining the initial query depending on your purpose query = db.session.query().select_from(BookMain)","# ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link),","= form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite =","form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data","redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from .","\"\"\" # Known bugs that can't be fixed here: # - synopsis() cannot","BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\"","path will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from","searching the date # will search a date formatted equal to how it","the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue),","def post_book(): \"\"\" post new book entry :return: \"\"\" book = BookMain.query.all() id","= id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit ,","return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book","= book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data =","url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import book","line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" #","if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement,","# ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose query","form.body.data = temp # flash('Your book data has been updated.', 'success') # return","import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from","'POST']) def get_book(): return f\"Hello book index : {id}\" @book.route('/post/', methods=['GET', 'POST']) def","coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line application to run","# GET parameters params = request.args.to_dict() # instantiating a DataTable for the query","been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data =","book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST'])","form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def","render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from","query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET',","cast date to string, so string searching the date # will search a","side data.\"\"\" # defining columns # - explicitly cast date to string, so","# :param order: asc or desc # :return: renew query # \"\"\" #","error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book():","methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining columns # -","params = request.args.to_dict() # instantiating a DataTable for the query and table needed","--------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >=","initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params","from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import","columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST'])","from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query","= temp # flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta'))","print(f\"booksn is : {booksn}\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp #","= form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data","form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta',","by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index","If the __file__ attribute on a module is a relative path and #","post new book entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) +","ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ]","book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been","book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info","flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required,","form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \"\"\" edit , put book data :param","be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import","1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return","# print(temp) form.body.data = temp # flash('Your book data has been updated.', 'success')","order: asc or desc # :return: renew query # \"\"\" # books =","def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination","on your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() #","query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params =","query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query =","os.chdir(), an incorrect # path will be displayed. from flask import render_template, redirect,","= request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books =","Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for","%fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def",": {id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data","form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data","# \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List","request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items","date formatted equal to how it is presented # in the table columns","book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form)","ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), #","a relative path and # the current directory is changed with os.chdir(), an","ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] #","= book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html',","= form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter =","= form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit()","form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data","import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is","can't be fixed here: # - synopsis() cannot be prevented from clobbering existing","book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return","book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite","flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import book from","= book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book","= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.',","return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page","# --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration","-*- \"\"\" example.py ~~~~~~~~~ A simple command line application to run flask apps.","int(book[-1].id) + 1 print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id","python3 # -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command line","search a date formatted equal to how it is presented # in the","1 print(f\"id is : {id}\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data","'POST']) def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def","db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST'])","%s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET',","query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page,","return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html')","- If the __file__ attribute on a module is a relative path and","flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from","@book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry :return: \"\"\" book","book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info","book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link","example.py ~~~~~~~~~ A simple command line application to run flask apps. :copyright: 2019","flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return","loaded modules. # - If the __file__ attribute on a module is a","db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id","form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello","prevented from clobbering existing # loaded modules. # - If the __file__ attribute","the __file__ attribute on a module is a relative path and # the","to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs","# returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def","= form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year =","#!/usr/bin/env python3 # -*- coding: utf-8 -*- \"\"\" example.py ~~~~~~~~~ A simple command","form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data","form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success')","db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models","book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__","incorrect # path will be displayed. from flask import render_template, redirect, request, url_for,","# instantiating a DataTable for the query and table needed rowTable = DataTables(params,","form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data","datatables import ColumnDT, DataTables from .. import auth from .. import db from","'POST']) def post_book(): \"\"\" post new book entry :return: \"\"\" book = BookMain.query.all()","EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data","a DataTable for the query and table needed rowTable = DataTables(params, query, columns)","from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables","= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index'))","your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating","@book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET',","relative path and # the current directory is changed with os.chdir(), an incorrect","query # \"\"\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\"/list\") def list_book():","form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data","[ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) #","ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), #","= book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data =","the query and table needed rowTable = DataTables(params, query, columns) # returns what","name # :param order: asc or desc # :return: renew query # \"\"\"","~~~~~~~~~ A simple command line application to run flask apps. :copyright: 2019 Miller","return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index : {id}\"","data.\"\"\" # defining columns # - explicitly cast date to string, so string","# from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines","# path will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app","methods=['GET', 'POST']) def del_book(id): return f\"Hello book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST'])","has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data","\"\"\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data","ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), #","# - explicitly cast date to string, so string searching the date #","= form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed =","flask_login import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import","HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common","table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter),","= HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\"booksn is : {booksn}\") temp","for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration:","jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\"Hello book index : {id}\" @book.route('/post/',","desc # :return: renew query # \"\"\" # books = BookMain.get_all_book() # return","response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page =","book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter",".. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book","pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) #","data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn","<= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \"\"\"Return server side data.\"\"\"","query and table needed rowTable = DataTables(params, query, columns) # returns what is","'POST']) def data(): \"\"\"Return server side data.\"\"\" # defining columns # - explicitly","apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't be","in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n'","entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\"id is","form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data","# \"\"\" # # :param field: col name # :param order: asc or","(query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book()","\"\"\" post new book entry :return: \"\"\" book = BookMain.query.all() id = int(book[-1].id)","changed with os.chdir(), an incorrect # path will be displayed. from flask import","field: col name # :param order: asc or desc # :return: renew query","= book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data =","return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id):","index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination =","server side data.\"\"\" # defining columns # - explicitly cast date to string,","book index: del {id}\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \"\"\" :return: \"\"\" from","book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short","form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data","get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has been updated.',","here: # - synopsis() cannot be prevented from clobbering existing # loaded modules.","from .. import auth from .. import db from .forms import EditBookForm, HackmdMeta","BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if",": {id}\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry :return:","instantiating a DataTable for the query and table needed rowTable = DataTables(params, query,","simple command line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause","application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \"\"\" # Known","@book.route(\"/list\") def list_book(): \"\"\"List users with DataTables <= 1.10.x.\"\"\" return render_template('book/list_book.html') @book.route('/data', methods=['GET',","data(): \"\"\"Return server side data.\"\"\" # defining columns # - explicitly cast date","form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data","ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the","book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed","page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) #","# defining columns # - explicitly cast date to string, so string searching","form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your","explicitly cast date to string, so string searching the date # will search","form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has","edit , put book data :param id: :return: \"\"\" form = EditBookForm() book","a module is a relative path and # the current directory is changed","current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\nParameters: %s\\nDuration: %fs\\nContext: %s\\n' % (query.statement, query.parameters, query.duration, query.context))","list_book(): # \"\"\" # # :param field: col name # :param order: asc","methods=['GET', 'POST']) def post_book(): \"\"\" post new book entry :return: \"\"\" book =","2019 Miller :license: BSD-3-Clause \"\"\" # Known bugs that can't be fixed here:"],"string":"[\n \"= book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET',\",\n \"from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request\",\n \"render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # # :param\",\n \"col name # :param order: asc or desc # :return: renew query #\",\n \"index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta\",\n \"id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put\",\n \"get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\"\",\n \"return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post\",\n \"import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import\",\n \"'POST']) # def list_book(): # \\\"\\\"\\\" # # :param field: col name #\",\n \"BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data\",\n \"form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data\",\n \".forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain\",\n \"form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data\",\n \"book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year\",\n \"@book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow\",\n \"a date formatted equal to how it is presented # in the table\",\n \"ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose query =\",\n \"= form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note =\",\n \"booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp)\",\n \"form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data\",\n \"been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__': pass\",\n \"return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # #\",\n \"will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login\",\n \">= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration,\",\n \"from datatables import ColumnDT, DataTables from .. import auth from .. import db\",\n \"what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return\",\n \"# the current directory is changed with os.chdir(), an incorrect # path will\",\n \"for the query and table needed rowTable = DataTables(params, query, columns) # returns\",\n \"methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data :param id: :return:\",\n \"EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title\",\n \"# will search a date formatted equal to how it is presented #\",\n \"book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year\",\n \"__file__ attribute on a module is a relative path and # the current\",\n \":return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn =\",\n \"render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns\",\n \"'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int)\",\n \"from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) #\",\n \"temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has\",\n \"form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data\",\n \"flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data\",\n \"Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed here: #\",\n \"query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/',\",\n \"= get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has been\",\n \"{id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta\",\n \"db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id\",\n \"BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed here: # - synopsis()\",\n \"purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a\",\n \"book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link\",\n \"form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data\",\n \"book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint\",\n \"= book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data =\",\n \"from flask_login import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy\",\n \"def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book():\",\n \"string, so string searching the date # will search a date formatted equal\",\n \"book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book)\",\n \":param order: asc or desc # :return: renew query # \\\"\\\"\\\" # books\",\n \"= book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data =\",\n \"flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't\",\n \"del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\"\",\n \"type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination)\",\n \"hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit():\",\n \"= pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\"\",\n \"1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" #\",\n \"that can't be fixed here: # - synopsis() cannot be prevented from clobbering\",\n \"= BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'],\",\n \"print(temp) form.body.data = temp # flash('Your book data has been updated.', 'success') #\",\n \"added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST'])\",\n \"\\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to run flask apps. :copyright:\",\n \"= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.',\",\n \"EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # ---------------------------------------------------------\",\n \"how it is presented # in the table columns = [ # ColumnDT(cast(BookMain.id,\",\n \"ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint),\",\n \"page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books\",\n \"ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite)\",\n \"# ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial\",\n \"or desc # :return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() #\",\n \"form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data\",\n \":return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id =\",\n \"def edit_book(id): \\\"\\\"\\\" edit , put book data :param id: :return: \\\"\\\"\\\" form\",\n \"form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data\",\n \"@book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # # :param field: col\",\n \"cannot be prevented from clobbering existing # loaded modules. # - If the\",\n \"with os.chdir(), an incorrect # path will be displayed. from flask import render_template,\",\n \"redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title\",\n \"ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose\",\n \"the initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters\",\n \"request.args.to_dict() # instantiating a DataTable for the query and table needed rowTable =\",\n \"# :param field: col name # :param order: asc or desc # :return:\",\n \"form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data\",\n \"= str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data\",\n \"\\\"\\\"\\\" # # :param field: col name # :param order: asc or desc\",\n \":param field: col name # :param order: asc or desc # :return: renew\",\n \"# ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending\",\n \"form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>',\",\n \"booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def\",\n \"form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =\",\n \"logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression\",\n \"= form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link =\",\n \"\\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn\",\n \"@book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data :param id:\",\n \":param id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): #\",\n \"if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title\",\n \"render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data',\",\n \"= form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info =\",\n \"= form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint =\",\n \"routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning(\",\n \"from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from\",\n \"return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining\",\n \"db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data =\",\n \"'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response\",\n \"in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title),\",\n \"import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries():\",\n \"data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form)\",\n \"\\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data)\",\n \"columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year),\",\n \"def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta():\",\n \"auth from .. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels\",\n \"query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query\",\n \"depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict()\",\n \":return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\")\",\n \"users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return\",\n \"parameters params = request.args.to_dict() # instantiating a DataTable for the query and table\",\n \"import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user\",\n \"= query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/',\",\n \"module is a relative path and # the current directory is changed with\",\n \"methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST'])\",\n \"= int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit():\",\n \"sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import auth from\",\n \"defining columns # - explicitly cast date to string, so string searching the\",\n \"A simple command line application to run flask apps. :copyright: 2019 Miller :license:\",\n \"with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server\",\n \"book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book\",\n \"book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return\",\n \"return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del\",\n \"# return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return\",\n \"DataTables(params, query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>',\",\n \"path and # the current directory is changed with os.chdir(), an incorrect #\",\n \"existing # loaded modules. # - If the __file__ attribute on a module\",\n \"after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters:\",\n \"# ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining\",\n \"\\\"\\\"\\\" edit , put book data :param id: :return: \\\"\\\"\\\" form = EditBookForm()\",\n \"asc or desc # :return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book()\",\n \"methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1,\",\n \"DataTable for the query and table needed rowTable = DataTables(params, query, columns) #\",\n \"# - synopsis() cannot be prevented from clobbering existing # loaded modules. #\",\n \"needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book\",\n \"will search a date formatted equal to how it is presented # in\",\n \"= EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data\",\n \"'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def\",\n \"has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>',\",\n \"{id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short\",\n \"from .. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import\",\n \"book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note\",\n \"displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user,\",\n \"cast from datatables import ColumnDT, DataTables from .. import auth from .. import\",\n \"string searching the date # will search a date formatted equal to how\",\n \"needed rowTable = DataTables(params, query, columns) # returns what is needed by DataTable\",\n \"has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ == '__main__':\",\n \"+ 1 print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id =\",\n \"equal to how it is presented # in the table columns = [\",\n \"= BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short =\",\n \"from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import auth\",\n \"it is presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)),\",\n \"formatted equal to how it is presented # in the table columns =\",\n \"and # the current directory is changed with os.chdir(), an incorrect # path\",\n \"is presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id),\",\n \"DataTables from .. import auth from .. import db from .forms import EditBookForm,\",\n \"book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return\",\n \"booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in\",\n \"books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): #\",\n \"# books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with\",\n \"request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import\",\n \"book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data =\",\n \"synopsis() cannot be prevented from clobbering existing # loaded modules. # - If\",\n \"book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed\",\n \"get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is :\",\n \"books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate(\",\n \"ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on\",\n \"form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return\",\n \"returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book():\",\n \"bugs that can't be fixed here: # - synopsis() cannot be prevented from\",\n \"updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short\",\n \"booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn\",\n \":copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed\",\n \"from clobbering existing # loaded modules. # - If the __file__ attribute on\",\n \"form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data\",\n \"= [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info)\",\n \"an incorrect # path will be displayed. from flask import render_template, redirect, request,\",\n \"book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note\",\n \"= form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue =\",\n \"{booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data\",\n \"-*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to\",\n \"date # will search a date formatted equal to how it is presented\",\n \"= BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <=\",\n \"- synopsis() cannot be prevented from clobbering existing # loaded modules. # -\",\n \"@book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page',\",\n \"to how it is presented # in the table columns = [ #\",\n \"book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite\",\n \"%s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST'])\",\n \"so string searching the date # will search a date formatted equal to\",\n \"% (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): #\",\n \"'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data\",\n \"query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query\",\n \"# print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp\",\n \"import auth from .. import db from .forms import EditBookForm, HackmdMeta # from\",\n \"import ColumnDT, DataTables from .. import auth from .. import db from .forms\",\n \"= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index'))\",\n \"book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue\",\n \"query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext:\",\n \"data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit():\",\n \"be fixed here: # - synopsis() cannot be prevented from clobbering existing #\",\n \"table needed rowTable = DataTables(params, query, columns) # returns what is needed by\",\n \"db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data =\",\n \"import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from ..\",\n \"form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit\",\n \"edit_book(id): \\\"\\\"\\\" edit , put book data :param id: :return: \\\"\\\"\\\" form =\",\n \"id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form = EditBookForm() if\",\n \"is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your\",\n \"query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable\",\n \"data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__ ==\",\n \"login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import\",\n \"= book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data =\",\n \"import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain #\",\n \"def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta() if\",\n \"be prevented from clobbering existing # loaded modules. # - If the __file__\",\n \"put book data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404()\",\n \"# def list_book(): # \\\"\\\"\\\" # # :param field: col name # :param\",\n \"import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries\",\n \"@book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns #\",\n \"= EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn =\",\n \"from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user,\",\n \"presented # in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn),\",\n \"utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to run flask\",\n \"been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET',\",\n \"modules. # - If the __file__ attribute on a module is a relative\",\n \"'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data :param id: :return: \\\"\\\"\\\"\",\n \"import cast from datatables import ColumnDT, DataTables from .. import auth from ..\",\n \"book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT,\",\n \"post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id =\",\n \"book data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if\",\n \"new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1\",\n \"- explicitly cast date to string, so string searching the date # will\",\n \"pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" #\",\n \"= book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data =\",\n \"renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def\",\n \"per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def\",\n \"'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form = HackmdMeta()\",\n \"form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn\",\n \"ColumnDT, DataTables from .. import auth from .. import db from .forms import\",\n \"attribute on a module is a relative path and # the current directory\",\n \"the current directory is changed with os.chdir(), an incorrect # path will be\",\n \"run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that\",\n \"book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book\",\n \"\\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\")\",\n \"temp # flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return\",\n \"form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success')\",\n \"del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import\",\n \"book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint\",\n \"\\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users\",\n \"GET parameters params = request.args.to_dict() # instantiating a DataTable for the query and\",\n \"# ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your\",\n \"# @book.route('/list/', methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # # :param field:\",\n \"current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return\",\n \"defining the initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET\",\n \"# books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id,\",\n \"= request.args.to_dict() # instantiating a DataTable for the query and table needed rowTable\",\n \"directory is changed with os.chdir(), an incorrect # path will be displayed. from\",\n \"= BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form =\",\n \"def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # - explicitly cast\",\n \"date to string, so string searching the date # will search a date\",\n \"# :return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books)\",\n \"columns # - explicitly cast date to string, so string searching the date\",\n \"= DataTables(params, query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result())\",\n \"flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if\",\n \"query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters,\",\n \"db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable for the\",\n \"# in the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short),\",\n \"rowTable = DataTables(params, query, columns) # returns what is needed by DataTable return\",\n \"form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) #\",\n \"HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp =\",\n \"is a relative path and # the current directory is changed with os.chdir(),\",\n \"render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\"\",\n \"render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data\",\n \"fixed here: # - synopsis() cannot be prevented from clobbering existing # loaded\",\n \"login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import get_debug_queries from\",\n \"book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index:\",\n \"get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from .. import\",\n \"# flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form)\",\n \"# book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data\",\n \"DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side\",\n \"get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' %\",\n \":return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is :\",\n \"ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed),\",\n \"book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue\",\n \"Known bugs that can't be fixed here: # - synopsis() cannot be prevented\",\n \"if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title =\",\n \"# -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application\",\n \"db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note),\",\n \"return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data =\",\n \"@book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET',\",\n \"%s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index():\",\n \"is changed with os.chdir(), an incorrect # path will be displayed. from flask\",\n \"ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), #\",\n \"index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry\",\n \"return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return:\",\n \"= db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating a DataTable for\",\n \"methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form =\",\n \"form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data\",\n \"books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables\",\n \"f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\"\",\n \"@book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from booktags.vendor.hackmd_meta import get_hackmdmeta form\",\n \".. import auth from .. import db from .forms import EditBookForm, HackmdMeta #\",\n \"book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form\",\n \"# defining the initial query depending on your purpose query = db.session.query().select_from(BookMain) #\",\n \"common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']:\",\n \"= book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data =\",\n \"form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\")\",\n \"= book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data =\",\n \"if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn)\",\n \"import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response):\",\n \"# # :param field: col name # :param order: asc or desc #\",\n \"on a module is a relative path and # the current directory is\",\n \"form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short =\",\n \"<reponame>MagicSword/Booktags #!/usr/bin/env python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple\",\n \"= book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id):\",\n \"str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data =\",\n \"clobbering existing # loaded modules. # - If the __file__ attribute on a\",\n \"ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the initial query\",\n \"DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index :\",\n \"def after_request(response): for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query:\",\n \"BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form = EditBookForm()\",\n \"\\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data():\",\n \"form.id.data = book.id form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data\",\n \"and table needed rowTable = DataTables(params, query, columns) # returns what is needed\",\n \"command line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\"\",\n \"list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def\",\n \"is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello\",\n \"{id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\"\",\n \". import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables\",\n \"def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST'])\",\n \":license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed here: # -\",\n \"redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\"\",\n \"book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html',\",\n \"form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data\",\n \"# loaded modules. # - If the __file__ attribute on a module is\",\n \"book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id\",\n \"BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False)\",\n \": {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book\",\n \"\\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # - explicitly cast date to\",\n \"f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new\",\n \"query, columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET',\",\n \"book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter\",\n \", put book data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book =\",\n \"to string, so string searching the date # will search a date formatted\",\n \"# Known bugs that can't be fixed here: # - synopsis() cannot be\",\n \"is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn =\",\n \"def list_book(): # \\\"\\\"\\\" # # :param field: col name # :param order:\",\n \"print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn\",\n \"methods=['GET', 'POST']) # def list_book(): # \\\"\\\"\\\" # # :param field: col name\",\n \"id: :return: \\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id\",\n \"# - If the __file__ attribute on a module is a relative path\",\n \"current directory is changed with os.chdir(), an incorrect # path will be displayed.\",\n \"current_user from . import book from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast\",\n \"the date # will search a date formatted equal to how it is\",\n \"] # defining the initial query depending on your purpose query = db.session.query().select_from(BookMain)\",\n \"# ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link),\",\n \"= form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite =\",\n \"form.isbn.data = book.isbn form.title_short.data = book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data\",\n \"redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from .\",\n \"\\\"\\\"\\\" # Known bugs that can't be fixed here: # - synopsis() cannot\",\n \"BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\"\",\n \"path will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from\",\n \"searching the date # will search a date formatted equal to how it\",\n \"the table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue),\",\n \"def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id\",\n \"= id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit ,\",\n \"return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book\",\n \"= book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data =\",\n \"url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import book\",\n \"line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" #\",\n \"if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement,\",\n \"# ColumnDT(BookMain.keepsite) ] # defining the initial query depending on your purpose query\",\n \"form.body.data = temp # flash('Your book data has been updated.', 'success') # return\",\n \"import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from\",\n \"'POST']) def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def\",\n \"coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to run\",\n \"# GET parameters params = request.args.to_dict() # instantiating a DataTable for the query\",\n \"been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data =\",\n \"book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST'])\",\n \"form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def\",\n \"render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from\",\n \"query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET',\",\n \"cast date to string, so string searching the date # will search a\",\n \"side data.\\\"\\\"\\\" # defining columns # - explicitly cast date to string, so\",\n \"# :param order: asc or desc # :return: renew query # \\\"\\\"\\\" #\",\n \"error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) # def list_book():\",\n \"methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # -\",\n \"params = request.args.to_dict() # instantiating a DataTable for the query and table needed\",\n \"--------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration >=\",\n \"initial query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params\",\n \"from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import\",\n \"columns) # returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST'])\",\n \"from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query\",\n \"= temp # flash('Your book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta'))\",\n \"print(f\\\"booksn is : {booksn}\\\") temp = get_hackmdmeta(booksn) # print(temp) form.body.data = temp #\",\n \"= form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data\",\n \"form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta',\",\n \"by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index\",\n \"If the __file__ attribute on a module is a relative path and #\",\n \"post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) +\",\n \"ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ]\",\n \"book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been\",\n \"book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info\",\n \"flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import login_user, logout_user, login_required,\",\n \"form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id): \\\"\\\"\\\" edit , put book data :param\",\n \"be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app from flask_login import\",\n \"1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return\",\n \"# print(temp) form.body.data = temp # flash('Your book data has been updated.', 'success')\",\n \"order: asc or desc # :return: renew query # \\\"\\\"\\\" # books =\",\n \"def index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination\",\n \"on your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() #\",\n \"query depending on your purpose query = db.session.query().select_from(BookMain) # GET parameters params =\",\n \"query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query =\",\n \"os.chdir(), an incorrect # path will be displayed. from flask import render_template, redirect,\",\n \"= request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books =\",\n \"Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for\",\n \"%fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def\",\n \": {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data\",\n \"form.copy_info.data = book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data\",\n \"# \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List\",\n \"request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items\",\n \"date formatted equal to how it is presented # in the table columns\",\n \"book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form)\",\n \"ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), #\",\n \"a relative path and # the current directory is changed with os.chdir(), an\",\n \"ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] #\",\n \"= book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html',\",\n \"= form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter =\",\n \"= form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit()\",\n \"form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data\",\n \"import get_hackmdmeta form = HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is\",\n \"can't be fixed here: # - synopsis() cannot be prevented from clobbering existing\",\n \"book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return\",\n \"book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite\",\n \"flash,jsonify,current_app from flask_login import login_user, logout_user, login_required, current_user from . import book from\",\n \"= book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book\",\n \"= form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.',\",\n \"return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page\",\n \"# --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if query.duration\",\n \"-*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line application to run flask apps.\",\n \"int(book[-1].id) + 1 print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id\",\n \"python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command line\",\n \"search a date formatted equal to how it is presented # in the\",\n \"1 print(f\\\"id is : {id}\\\") form = EditBookForm() if form.validate_on_submit(): book.id = form.id.data\",\n \"'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def\",\n \"db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST'])\",\n \"%s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET',\",\n \"query = BookMain.query page = request.args.get('page', 1, type=int) pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page,\",\n \"return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html')\",\n \"- If the __file__ attribute on a module is a relative path and\",\n \"flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables from\",\n \"@book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book\",\n \"book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info\",\n \"book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data book.get_link\",\n \"example.py ~~~~~~~~~ A simple command line application to run flask apps. :copyright: 2019\",\n \"flash('Your book data has been added.', 'success') return redirect(url_for('book.index')) form.id.data = id return\",\n \"loaded modules. # - If the __file__ attribute on a module is a\",\n \"db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id\",\n \"form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello\",\n \"prevented from clobbering existing # loaded modules. # - If the __file__ attribute\",\n \"the __file__ attribute on a module is a relative path and # the\",\n \"to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs\",\n \"# returns what is needed by DataTable return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def\",\n \"= form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year =\",\n \"#!/usr/bin/env python3 # -*- coding: utf-8 -*- \\\"\\\"\\\" example.py ~~~~~~~~~ A simple command\",\n \"form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data book.copy_info = form.copy_info.data\",\n \"form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success')\",\n \"db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models\",\n \"book data has been updated.', 'success') # return redirect(url_for('book.hackmd_meta')) return render_template('book/hackmd_meta.html',form=form) if __name__\",\n \"incorrect # path will be displayed. from flask import render_template, redirect, request, url_for,\",\n \"# instantiating a DataTable for the query and table needed rowTable = DataTables(params,\",\n \"form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter = form.cutter.data book.pub_year = form.pub_year.data\",\n \"datatables import ColumnDT, DataTables from .. import auth from .. import db from\",\n \"'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all()\",\n \"EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data\",\n \"a DataTable for the query and table needed rowTable = DataTables(params, query, columns)\",\n \"from flask_sqlalchemy import get_debug_queries from sqlalchemy.sql.expression import cast from datatables import ColumnDT, DataTables\",\n \"= form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been added.', 'success') return redirect(url_for('book.index'))\",\n \"your purpose query = db.session.query().select_from(BookMain) # GET parameters params = request.args.to_dict() # instantiating\",\n \"@book.route('/del/<int:id>', methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET',\",\n \"relative path and # the current directory is changed with os.chdir(), an incorrect\",\n \"query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return render_template('book/list_book.html',books=books) @book.route(\\\"/list\\\") def list_book():\",\n \"form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data\",\n \"[ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) #\",\n \"ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), #\",\n \"= book.catalogue form.cutter.data = book.cutter form.pub_year.data = book.pub_year form.copy_info.data = book.copy_info form.get_link.data =\",\n \"the query and table needed rowTable = DataTables(params, query, columns) # returns what\",\n \"name # :param order: asc or desc # :return: renew query # \\\"\\\"\\\"\",\n \"~~~~~~~~~ A simple command line application to run flask apps. :copyright: 2019 Miller\",\n \"return jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index : {id}\\\"\",\n \"data.\\\"\\\"\\\" # defining columns # - explicitly cast date to string, so string\",\n \"# from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common routines\",\n \"# path will be displayed. from flask import render_template, redirect, request, url_for, flash,jsonify,current_app\",\n \"methods=['GET', 'POST']) def del_book(id): return f\\\"Hello book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST'])\",\n \"has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn form.title_short.data\",\n \"\\\"\\\"\\\" form = EditBookForm() book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data\",\n \"ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter), ColumnDT(BookMain.pub_year), ColumnDT(BookMain.copy_info) # ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), #\",\n \"# - explicitly cast date to string, so string searching the date #\",\n \"= form.copy_info.data book.get_link = form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed =\",\n \"flask_login import login_user, logout_user, login_required, current_user from . import book from flask_sqlalchemy import\",\n \"HackmdMeta # from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # --------------------------------------------------------- common\",\n \"table columns = [ # ColumnDT(cast(BookMain.id, db.Integer)), ColumnDT(BookMain.id), ColumnDT(BookMain.isbn), ColumnDT(BookMain.title_short), ColumnDT(BookMain.title), ColumnDT(BookMain.catalogue), ColumnDT(BookMain.cutter),\",\n \"= HackmdMeta() if form.validate_on_submit(): booksn = str(form.booksn.data) # print(f\\\"booksn is : {booksn}\\\") temp\",\n \"for query in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration:\",\n \"jsonify(rowTable.output_result()) @book.route('/get/<int:id>', methods=['GET', 'POST']) def get_book(): return f\\\"Hello book index : {id}\\\" @book.route('/post/',\",\n \"desc # :return: renew query # \\\"\\\"\\\" # books = BookMain.get_all_book() # return\",\n \"response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book() query = BookMain.query page =\",\n \"book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data book.catalogue = form.catalogue.data book.cutter\",\n \".. import db from .forms import EditBookForm, HackmdMeta # from booktags.db.basemodels import Book\",\n \"pagination = query.order_by(cast(BookMain.id, db.Integer)).paginate( page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) #\",\n \"data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data = book.id form.isbn.data = book.isbn\",\n \"<= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET', 'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\"\",\n \"query and table needed rowTable = DataTables(params, query, columns) # returns what is\",\n \"'POST']) def data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # - explicitly\",\n \"apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be\",\n \"in get_debug_queries(): if query.duration >= current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n'\",\n \"entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id) + 1 print(f\\\"id is\",\n \"form.validate_on_submit(): book.id = form.id.data book.isbn = form.isbn.data book.title_short = form.title_short.data book.title = form.title.data\",\n \"# \\\"\\\"\\\" # # :param field: col name # :param order: asc or\",\n \"(query.statement, query.parameters, query.duration, query.context)) return response @book.route('/', methods=['GET', 'POST']) def index(): # books=BookMain.get_all_book()\",\n \"\\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book = BookMain.query.all() id = int(book[-1].id)\",\n \"changed with os.chdir(), an incorrect # path will be displayed. from flask import\",\n \"field: col name # :param order: asc or desc # :return: renew query\",\n \"= book.title_short form.title.data = book.title form.catalogue.data = book.catalogue form.cutter.data = book.cutter form.pub_year.data =\",\n \"return redirect(url_for('book.index')) form.id.data = id return render_template('book/edit_book.html', form=form) @book.route('/edit/<int:id>', methods=['GET', 'POST']) def edit_book(id):\",\n \"index(): # books=BookMain.get_all_book() query = BookMain.query page = request.args.get('page', 1, type=int) pagination =\",\n \"server side data.\\\"\\\"\\\" # defining columns # - explicitly cast date to string,\",\n \"book index: del {id}\\\" @book.route('/hackmdmeta', methods=['GET', 'POST']) def hackmd_meta(): \\\"\\\"\\\" :return: \\\"\\\"\\\" from\",\n \"book = BookMain.query.filter_by(id=id).first_or_404() if form.validate_on_submit(): # book.id = form.id.data book.isbn = form.isbn.data book.title_short\",\n \"form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has been updated.', 'success') return redirect(url_for('book.index')) form.id.data\",\n \"get_hackmdmeta(booksn) # print(temp) form.body.data = temp # flash('Your book data has been updated.',\",\n \"here: # - synopsis() cannot be prevented from clobbering existing # loaded modules.\",\n \"from .. import auth from .. import db from .forms import EditBookForm, HackmdMeta\",\n \"BookMain # --------------------------------------------------------- common routines @book.after_app_request def after_request(response): for query in get_debug_queries(): if\",\n \": {id}\\\" @book.route('/post/', methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return:\",\n \"instantiating a DataTable for the query and table needed rowTable = DataTables(params, query,\",\n \"simple command line application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause\",\n \"application to run flask apps. :copyright: 2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known\",\n \"@book.route(\\\"/list\\\") def list_book(): \\\"\\\"\\\"List users with DataTables <= 1.10.x.\\\"\\\"\\\" return render_template('book/list_book.html') @book.route('/data', methods=['GET',\",\n \"data(): \\\"\\\"\\\"Return server side data.\\\"\\\"\\\" # defining columns # - explicitly cast date\",\n \"form.get_link.data book.note = form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data\",\n \"ColumnDT(BookMain.get_link), # ColumnDT(BookMain.note), # ColumnDT(BookMain.reprint), # ColumnDT(BookMain.removed), # ColumnDT(BookMain.keepsite) ] # defining the\",\n \"book.copy_info form.get_link.data = book.get_link form.note.data = book.note form.reprint.data = book.reprint form.removed.data = book.removed\",\n \"page, per_page=current_app.config['PROJECT_BOOKS_PER_PAGE'], error_out=False) books = pagination.items return render_template('book/index.html',books=books,pagination=pagination) # @book.route('/list/', methods=['GET', 'POST']) #\",\n \"# defining columns # - explicitly cast date to string, so string searching\",\n \"form.note.data book.reprint = form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your\",\n \"explicitly cast date to string, so string searching the date # will search\",\n \"form.reprint.data book.removed = form.removed.data book.keepsite = form.keepsite.data db.session.add(book) db.session.commit() flash('Your book data has\",\n \"edit , put book data :param id: :return: \\\"\\\"\\\" form = EditBookForm() book\",\n \"a module is a relative path and # the current directory is changed\",\n \"current_app.config['PROJECT_SLOW_DB_QUERY_TIME']: current_app.logger.warning( 'Slow query: %s\\\\nParameters: %s\\\\nDuration: %fs\\\\nContext: %s\\\\n' % (query.statement, query.parameters, query.duration, query.context))\",\n \"list_book(): # \\\"\\\"\\\" # # :param field: col name # :param order: asc\",\n \"methods=['GET', 'POST']) def post_book(): \\\"\\\"\\\" post new book entry :return: \\\"\\\"\\\" book =\",\n \"2019 Miller :license: BSD-3-Clause \\\"\\\"\\\" # Known bugs that can't be fixed here:\"\n]","isConversational":false}}},{"rowIdx":2499,"cells":{"ngram":{"kind":"list like","value":["= 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js =","'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg =","content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html","'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg'","from enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif =","'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp'","ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png","gif = 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg","js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json'","class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html'","# https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html =","= 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt =","https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html'","'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain;","= 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png =","htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg","html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js","'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json =","= 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico =","'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png'","= 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg =","css = 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico","'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript'","jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii'","= 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg","= 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json","Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm =","'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg'","png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg = 'image/svg+xml'","= 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg =","jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt","enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif'","import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm"],"string":"[\n \"= 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js =\",\n \"'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg =\",\n \"content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html\",\n \"'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg'\",\n \"from enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif =\",\n \"'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp'\",\n \"ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png\",\n \"gif = 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg\",\n \"js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json'\",\n \"class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html'\",\n \"# https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html =\",\n \"= 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt =\",\n \"https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html'\",\n \"'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain;\",\n \"= 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png =\",\n \"htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg\",\n \"html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js\",\n \"'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json =\",\n \"= 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico =\",\n \"'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png'\",\n \"= 'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg =\",\n \"css = 'text/css' gif = 'image/gif' htm = 'text/html' html = 'text/html' ico\",\n \"'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript'\",\n \"jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii'\",\n \"= 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg\",\n \"= 'image/jpeg' js = 'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json\",\n \"Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm =\",\n \"'image/gif' htm = 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg'\",\n \"png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg = 'image/svg+xml'\",\n \"= 'text/html' html = 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg =\",\n \"jpg = 'image/jpeg' jpeg = 'image/jpeg' js = 'application/javascript' png = 'image/png' txt\",\n \"enum import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif'\",\n \"import Enum class content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gif' htm\"\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":24,"numItemsPerPage":100,"numTotalItems":12866649,"offset":2400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6Im1sR1pFYktIVHRVSGRhX1RRdEczQ0N1S3k5ME9Qd25DNHY5elRjM3FVYzgifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MzQ1NDU0NiwianRpIjoiZWFiZmZhMGYtYTZjMi00MDRmLWI2YTItZTMwNDUxYzdjYjU4Iiwic3ViIjoiL2RhdGFzZXRzL3RlcnJ5eXovc3RhcmNvZGVyZGF0YV9uZ3JhbV8xMyIsImV4cCI6MTc4MzQ1ODE0NiwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.oAFu7RlrUYbLC3aoYOqElMFRoEgLQqBcxZ-PNudKKCkp_NUYrIL2IRY3CrvrT3BlyGnJXxRbmXwTLQeaNt4yAA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":12866649,"numBytesParquet":149232926747}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
ngram listlengths 0 67.8k |
|---|
[
"install_requires=[\"gfootball>=2.8\",], # metadata to display on PyPI author=\"<NAME>\", author_email=\"<EMAIL>\", description=\"Soccer trajectory and event",
"packages=find_packages(), # Project uses reStructuredText, so ensure that the docutils get # installed",
"project home page, if any project_urls={ \"Is... |
[
"6, 7, 8, 9, 10, 11]) n_decoys = pd.Series([0, 0, 1, 1, 1,",
"'+Ag', 0.75], ['C2H2', '+Ar', 0.0], ], columns=['formula', 'modifier', 'msm'], ) exp_sf_df = pd.DataFrame(",
"msm_df = pd.DataFrame( [ ['C1', '+H', 1.0], ['C2', '+H', 0.75], ['C3', '+H', 0.5],",
"'decoy_sample_size': decoy_sample_size} fdr = FDR( f... |
[] |
[
"= df[column] p = price.rolling(lookback).apply(end_price, raw=True).shift(-lookback+1) t = price.rolling(lookback).apply(end_time, raw=True).shift(-lookback+1) t = pd.Series(",
"[t.index[int(k+i)] if not math.isnan(k+i) else np.datetime64('NaT') for i, k in enumerate(t)], index=t.index ).dropna()",
"np import ... |
[
"*args, **kwargs)) except OSError: pass def create_image_cache_filename(input_filepath, *args, **kwargs): if input_filepath: hash_value =",
"} ) try: backend.convert_file(input_filepath=input_filepath, output_filepath=output_filepath, transformations=transformations, page=page, file_format=file_format, mimetype=m... |
[
"calc decision boundary # The decision boundary is the threshold line that separates",
"# plot admitted plt.scatter(x_mat[admitted, 0], x_mat[admitted, 1], color='blue', marker='+') # plot rejected plt.scatter(x_mat[rejected,",
"# predict for student joe = np.array([[45, 85]]) joe_norm = (joe - x_mean)",
"# a... |
[
"handler used for profiling processing times t = self._processing_timer.value() self.processing_times.append(t) def _timeit_dataflow(self) ->",
"1: std = round(torch.std(data).item(), 5) return [total, min_index, max_index, mean, std] event_handler_stats =",
"given {type(engine)}\") if not engine.has_event_hand... |
[
"\"\"\" from __future__ import annotations from collections import namedtuple from datetime import datetime",
"quick compute) # - websockets with potential arbitrage (including fees - detailed data",
"to get: quote_curr -- (buy_price - fee) --> base_curr self.df[base][quote] = ((100 -",
"log import pandas as ... |
[
"BY-NC-SA 4.0 International Public License # (see LICENSE.md or https://creativecommons.org/licenses/by-nc-sa/4.0/) # \"\"\" The",
"Public License # (see LICENSE.md or https://creativecommons.org/licenses/by-nc-sa/4.0/) # \"\"\" The Snowtire binary sensor.",
"\"\"\" The Snowtire binary sensor. For more details ... |
[
"-8.48731256e-01], [ -7.67315597e-01, -6.24101927e-01], [ -2.32860808e+00, -1.02510436e-01], [ -3.06641866e-03, -5.78877778e+00], [ -9.85292840e-02, -2.36626165e+00],",
"[ 0.90616916, 0.09383084], [ 0.76969251, 0.23030749], [ 0.99798563, 0.00201437], [ 0.86297361, 0.13702639]] assert_array_almost_equal(y,",
"nu... |
[
"self.score[var] -= 1 def callback_factory(scoring: AbstactVariableScoring): if isinstance(scoring, VariableRanking): output = __build_callback__(scoring) else:",
"v in solution.vars.items()} def get_value(self, var_name): return self.score[var_name] def success_update_score(self, curr_kernel, curr_bucket): raise... |
[
"is being invoked by an old script wrapper. This will \" \"fail in",
"wrappers for the current one. \"\"\" sys.stderr.write( \"WARNING: pip is being invoked by",
"entrypoints defined. Because of issues arising from PATH, sys.path, multiple Pythons, their interactions,",
"mechanism for warning users and direct... |
[
"return def Sections_To_Lines(doc_text_sections): ''' Converts a dict of {section label: text} to a",
"and pick out the cues. tree = etree.parse(str(xml_path)) root = tree.xpath('/*')[0] cues =",
"= spec.root_path / rel_path # Get lines for all files. doc_lines = []",
"'overview', then a series of names of cu... |
[
"numbers a = 30 b = 17 print(\"Sum of a and b is\",a",
"= 30 b = 17 print(\"Sum of a and b is\",a + b)",
"two numbers a = 30 b = 17 print(\"Sum of a and b",
"#Addition of two numbers a = 30 b = 17 print(\"Sum of a",
"a = 30 b = 17 print(\"Sum of a and b is\",a +",
"of two numbers a = 30 b = 17 print(\"Sum... |
[
"<reponame>andersonssh/aprendendo-pyqt5<filename>curso 1/04 - caixa de texto/a4.py import sys from PyQt5.QtWidgets import (QApplication, QMainWindow,",
"color: white;} QPushButton:hover{ background: orange; font-weight: 600}') botao2.clicked.connect(self.b2) botao3 = QPushButton('Texto', self) botao3.move(500,",
... |
[
"svg += '''</svg>''' os.system('rm -rf /tmp/pdf2write') with open(f'{os.path.dirname(pdf_path)}/{os.path.basename(pdf_path).split(\".\")[0]}.svg', 'w') as f: f.write(svg) os.system(f'gzip",
"<int name=\"ruleColor\" value=\"0\" /> <float name=\"marginLeft\" value=\"0\" /> <float name=\"xOffset\" value=\"-380.70175... |
[
"-> ParameterValueType: param = self.get_parameter(name) return param.value def get_float_parameter_value(self, name: str) -> float:",
"' + name + ' already added to this object') parameter = Parameter(name,",
"parameter def add_parameter_object(self, parameter: Parameter) -> None: self._parameters[parameter.na... |
[
"encapsulates a Region Of Interest, which may be either horizontal # (pixels) or",
"horizontal # (pixels) or vertical (rows/lines). class ROI: def __init__(self, start, end): self.start",
"a Region Of Interest, which may be either horizontal # (pixels) or vertical",
"def crop(self, spectrum): return spectrum[... |
[
"0x00, 0x1E, 0x07, 0x80, 0x03, 0xE0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,",
"0x60, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xF3, 0xCF, 0x30, 0x9E, 0x79, 0xE7,",
"0x80, 0x87, 0x9E, 0x40, 0x8D, 0xE7, 0x9E, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00,",
"0x00, 0x00, 0x00, 0x1E, 0x07, 0x80, 0x03, 0xE0, 0xF8, 0x00, 0x00, ... |
[
"import bradley_thresholding_method from .contrast import contrast_thresholding_method from .feng import feng_thresholding_method from .gaussian import",
"from .sauvola import sauvola_thresholding_method from .singh import singh_thresholding_method from .two_peaks import two_peaks_thresholding_method from",
"fr... |
[
"= ( Queue('default', exchange=Exchange('default'), routing_key='default'), # Queue('aws_uploads', routing_key='video.uploads'), ) CELERY_DEFAULT_EXCHANGE = 'default' CELERY_DEFAULT_EXCHANGE_TYPE",
"CELERY_DEFAULT_EXCHANGE = 'default' CELERY_DEFAULT_EXCHANGE_TYPE = 'direct' CELERY_DEFAULT_ROUTING_KEY = 'default' ... |
[
"(date, total_time)) print(\"\") print(\"*\" * 50) def main(): # print(\"Checking environment variable TIMESHEET_URL",
"spreadsheet URL...\") user_full_name = os.environ.get('USER_FULL_NAME', \"\").strip() if not user_full_name: print(\"Warning: USER_FULL_NAME environment variable",
"row[COL_WORK_FROM_HOME] if ... |
[
"np.zeros((self.BATCH_SIZE, self.N_PLAYERS), dtype=float) hand_scores = self.evaluate_hands(community_cards, hole_cards, np.logical_not(folded)) ranks = np.argsort(hand_scores, axis=1) sorted_hands",
"folded stops game, improves performance but breaks tests # test is not broken,",
"None] total_winnings -= prev_... |
[
"def revert_plugins(request, version_id, obj): from reversion.models import Version version = get_object_or_404(Version, pk=version_id) revs",
"placeholders[pk].save() page.placeholders.add(placeholders[pk]) for plugin in cms_plugin_list: # connect plugins to the correct placeholder",
"= obj lang = get_language... |
[
"# 转化为int64 # print(label) label_gen_p = pd.DataFrame(label_gen_dict) label_gen_p.to_csv(gpath + 'label_delete.csv', index=False) # label_gen_p",
"train_path = './AgriculturalDisease_trainingset/' valid_path = './AgriculturalDisease_validationset/' def genImage(gpath, datatype): if datatype == 'train':",
"= './... |
[
"import random x = range(0, 120) y = [random.randint(20, 35) for i in",
"dpi=80) plt.plot(x, y) # 中文字体 chFont = font_manager.FontProperties(family=\"SimHei\") # SimHei # chFont =",
"= 10 xLabels = [\"10点,{}分\".format(i) for i in range(60)] xLabels += [\"11点,{}分\".format(i) for",
"= font_manager.FontProperties... |
[
"canvas.plot(data, isoline, bg=1) baseline = os.path.splitext(sys.argv[1]) baselineImage = \"%s%s\"%baseline ret = regression.run_wo_terminate(canvas, \"test_vcs_isoline_labels.png\",",
"isoline, bg=1) baselineImage = \"%s%d%s\"%(baseline[0], 2, baseline[1]) testImage = os.path.abspath(\"test_vcs_isoline_labels2.... |
[
"pnew = (1-laziness) * W.dot(p) + laziness * p0 l2norm = max(np.sqrt(sum((pnew -",
"not # % need normalization when predict y_pred_ICE. # % ixsp is another",
"stores the good cluster(s) for each instance, which may include even a remote",
"wrong leading entrie cluster prediction is wrong, which is the reason ... |
[
"tile_name, pin['wire']) cur.execute( \"\"\" SELECT track_pkey FROM node WHERE pkey = ( SELECT",
"REBUF stuff rebuf_key = (feature_path[0], feature_path[1]) if rebuf_key in REBUF_SOURCES: return ' '.join([feature]",
"and create synth_tiles input. All arches should have these synthetic tiles, search the",
"to ... |
[
"+ 'qPDFall.pdf',format='pdf', bbox_inches = 'tight') fecc.savefig('./plots/' + 'eccPDFall.pdf',format='pdf', bbox_inches = 'tight') flper.savefig('./plots/' +",
"eccentricity for Andrew's circularization plots eccAll = [] eccObs = [] eccRec =",
"axlper.step(lpb[0:-1], lphAll0/np.sum(lphAll0), color='black', al... |
[
"), cout = cms.untracked.PSet( threshold = cms.untracked.string( \"DEBUG\" ) ), destinations = cms.untracked.vstring(",
"### 2018 Prompt process.BeamSpotRcdPrinter.tagName = \"BeamSpotObjects_PCL_byLumi_v0_prompt\" process.BeamSpotRcdPrinter.startIOV = 1350646955507767 process.BeamSpotRcdPrinter.endIOV = 14068766... |
[
"import ( TokenObtainPairView, TokenRefreshView, TokenVerifyView ) urlpatterns = [ path('obtain/', TokenObtainPairView.as_view(), name='token_obtain_pair'), path('refresh/',",
"TokenVerifyView ) urlpatterns = [ path('obtain/', TokenObtainPairView.as_view(), name='token_obtain_pair'), path('refresh/', TokenRefresh... |
[
"storbinary must accepts a STRING, since it builds a cmd and add the",
"self.ftp.quit() except all_errors as e: sys.stderr.write(\"Error Closing FTP connection\\n\") sys.stderr.write(\"%s\\n\"%e) super().close() def fix(self,",
"# and is an accessable file. I can infer that a failure to",
"\"\", \"port\" : in... |
[
"1) def testYearProperty(self): \"\"\"Tests the year property.\"\"\" knowledge_base_object = knowledge_base.KnowledgeBase() self.assertEqual(knowledge_base_object.year, 0) def",
"knowledge_base_object = knowledge_base.KnowledgeBase() self.assertFalse(knowledge_base_object.HasUserAccounts()) user_account = artifac... |
[
"if dp[idx] is None: dp[idx] = [] # 将目前的所有方式全部添加到新的位置，并在每个的最后追加当前的单词 for dic in dp[i]:",
"for res in dp[-1]] def wordBreak_dfs(self, s: str, wordDict: List[str]) -> List[str]: def",
"+ combo) memo[s] = res return res return dfs(s) s = Solution() print(s.wordBreak_dfs('catsanddog',",
"if dp[i] is None: continu... |
[
"testlib_api.ExpectedException(SystemExit): self._main_test_helper( ['prog', 'revision', '--autogenerate', '--%s' % branch], 'revision') def test_revision_autogenerate_conflicts_with_expand(self): self._test_revision_autogenerate_conflicts_with_branch( cli.EXPAND_BRANCH)",
"Unless required by applicable law or ag... |
[
"= Decimal(floor) self.ceiling = Decimal(ceiling) self.rate = Decimal(rate) def start(self): amount = self.rate",
"Decimal(floor) self.ceiling = Decimal(ceiling) self.rate = Decimal(rate) def start(self): amount = self.rate *",
"= Decimal(ceiling) self.rate = Decimal(rate) def start(self): amount = self.rate * ... |
[
"else h humidity = h >> 12 if result: result[0] = temp result[1]",
"= self.read_compensated_data() pi = float(p // 256) pd = (p % 256)/256 return",
"self.dig_P9, \\ _, self.dig_H1 = unpack(\"<HhhHhhhhhhhhBB\", dig_88_a1) self.dig_H2, self.dig_H3 = unpack(\"<hB\", dig_e1_e7) e4_sign",
"read_compensated_data(se... |
[
"path of the secret to read Airflow Configurations (default: 'configs'). :type config_path: str",
"type: (str) -> Optional[str] \"\"\" Get secret value from Vault. Store the secret",
"distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY",
"elif self.auth_type == \"approle\": _client.au... |
[
"lap(\"Converting 'item' column value types...\") df['items'] = df['items'].apply(literal_eval) # Group DataFrame by character_id",
"adding nan pair los1 = items1.iloc[i] los2 = items2.iloc[i] pairs.append((los2, los1)) # Generate",
"by text similarity. Edit Distance Metrics - Levenshtein Distance - Damerau-Lev... |
[
"Board(array=array).legal_moves)) ) array[i][j] = 0 # underpromotion moves array[1, :] = Board.piece_symbol_to_int(\"P\") all_possible_moves.update(",
"moves array[1, :] = Board.piece_symbol_to_int(\"P\") all_possible_moves.update( set(map(lambda move: Move(uci=move.uci()), Board(array=array).legal_moves)) ) arra... |
[
"vehicle emc (float): electromechanical constant for the vehicle dt (float): simulation time step",
"= 0 else: y0dot = self.y1 y1dot = net_acceleration self.y0 += y0dot *",
"self.noise) return self.y0, self.y1 def get_altitude(self): \"\"\"Return the current altitude.\"\"\" return self.y0 def",
"self.dt = dt ... |
[
"import re from typing import Any, ClassVar, Dict, List, NoReturn, Union from cryptography.exceptions",
"id = resp['id'] desc = resp['descripcion'] if id == 0 and 'Cuenta en",
"InvalidInstitution, InvalidPassphrase, InvalidRfcOrCurp, InvalidTrackingKey, MandatoryField, NoOrdenesEncontradas, NoServiceResponse, P... |
[
"1 ); ul.selfTest() self.assertEqual( list(ul), [1,3,2]) ul.append_front( 2 ); ul.selfTest() self.assertEqual( list(ul), [2,1,3])",
"), \", \\t\\n\\r\" )(\"1,2, 3,,, \\n\\r\\t4\") self.assertEqual( l, [1,2,3,4] ) self.assertEqual( l, \"1,2,3,4\"",
"ul.selfTest() ul.append( 3 ); ul.selfTest() ul.append( 1 ); ul.... |
[
"+ log_writer_id + \"\\t\\t\" +str(self.date) + \"/\" + str(self.current_time) + \"\\t\\t\" +email+ \"\\t\\t\"",
"pass def log(self, file_object, email, log_message, log_writer_id): self.now = datetime.now() self.date = self.now.date()",
"= self.now.date() self.current_time = self.now.strftime(\"%H:%M:%S\") fil... |
[
"1024*MB # name of meta root dir META_DIR = \".metasync\" # batching time",
"of meta root dir META_DIR = \".metasync\" # batching time for daemon SYNC_WAIT",
"meta root dir META_DIR = \".metasync\" # batching time for daemon SYNC_WAIT =",
"for daemon SYNC_WAIT = 3 # blob size BLOB_UNIT = 32*MB # Increase",
... |
[
"test from py import valid_parentheses as vp class TestValidParentheses(unittest.TestCase): @test(vp.Solution.is_valid) def test_valid_parentheses(self) ->",
"-> None: test(\"()\", result=True) test(\"()[]{}\", result=True) test(\"(]\", result=False) test(\"([)]\", result=False) test(\"{[]}\", result=True) test(\... |
[
"return model def estimate_disparity(self, left_img, right_img): input_tensor = self.prepare_input(left_img, right_img) # Perform inference",
"= 0 self.camera_config = camera_config # Initialize model self.model = self.initialize_model(model_path, model_type) def",
"cv2.COLOR_BGR2RGB) right_img = cv2.cvtColor(r... |
[
"which the plugin belongs to def get_form_field_instances(self, request=None, form_entry=None, form_element_entries=None, **kwargs): field_kwargs =",
"plugin belongs to def get_form_field_instances(self, request=None, form_entry=None, form_element_entries=None, **kwargs): field_kwargs = { 'required':",
"forms f... |
[
"'Beam', 'Enemy', 'Friend', 'Hero', 'Launcher', 'Rotor', 'SpikeyBuddy', 'Star', 'Wizard', 'EnemyEquipedRotor', 'CyclingEnemyObject', 'Joints', 'Bomb',",
"'Enemy', 'Friend', 'Hero', 'Launcher', 'Rotor', 'SpikeyBuddy', 'Star', 'Wizard', 'EnemyEquipedRotor', 'CyclingEnemyObject', 'Joints', 'Bomb', 'Contacts']",
"_... |
[
"0): for step, data in enumerate(zip(self.data_loader, train_loader), 0): data_1 = data[0] _, caps,",
"fake_imgs = self.fake_imgs[idx] # netD.zero_grad() # Forward real_labels = self.real_labels[:batch_size] fake_labels = self.fake_labels[:batch_size]",
"!= '': state_dict = torch.load(cfg.TRAIN.NET_G) netG.load... |
[
"= request.forms.priimek#get(\"\") emso = request.forms.emso#get(\"\") drzava = request.forms.drzava#get(\"\") id_parcele = request.forms.id_parcele#get(\"\") od =",
"dobi_postavke_racuna import datetime as dt @bottle.get('/') def root(): redirect('/domov') @bottle.get('/domov') def index(): parcele",
"+ dt.tim... |
[
"from espnet.nets.pytorch_backend.transformer.initializer import initialize def initializer(model, args): \"\"\"Initialize transducer model. Args: model (torch.nn.Module):",
"model.dec.embed.weight.data.normal_(0, 1) for l in six.moves.range(len(model.dec.decoder)): set_forget_bias_to_one(model.dec.decoder[l].bia... |
[
"= model.N M = len( trace ) likelihoods = np.ones((N, 1)) if i",
"np.matrix(\"[ .02 0;\" \"0 0 0.5;\" \"0 0 0]\") P1 = np.matrix(\"[0.1 0",
"trace ) likelihoods = np.ones((N, 1)) if i < M: P = main.randomization(P0,",
"traces = traces_factory.traces P0 = np.matrix(\"[ .02 0;\" \"0 0 0.5;\" \"0 0",
"likeliho... |
[
"viewer.SetInputConnection(convertBack.GetOutputPort()) #viewer SetInputConnection [imageCanvas GetOutputPort] viewer.SetColorWindow(256) viewer.SetColorLevel(127.5) viewer.SetSize(320,320) viewer.Render() # --- end of",
"imageCanvas.FillBox(50,100,0,100) imageCanvas.SetDrawColor(0,255,0) imageCanvas.FillBox(100,... |
[
"csv class echa: def werehousing(self): with open('kelas_2b/echa.csv', 'r') as csvfile: csv_reader = csv.reader(csvfile,",
"import csv class echa: def werehousing(self): with open('kelas_2b/echa.csv', 'r') as csvfile: csv_reader =",
"def werehousing(self): with open('kelas_2b/echa.csv', 'r') as csvfile: csv_rea... |
[
"float(\"inf\")) y_pred, y = TEST_SAMPLE_4 sur_metric.update([y_pred, y]) self.assertAlmostEqual(sur_metric.compute(), float(\"inf\")) def test_shape_mismatch(self): sur_metric =",
"= np.ogrid[ -centre[0] : im_shape[0] - centre[0], -centre[1] : im_shape[1] - centre[1], -centre[2]",
"KIND, either express or impl... |
[
"= load_data(spec_file) max_rows = min(len(df), spec.get(\"max_rows\", 40000)) novelty_detection = spec.get(\"novelty\", True) normal_classes =",
"rows)\" % (name, 100*prec, k, len(y_test))) precision[name].append(prec) logging.info(\"* SUMMARY %s\", spec_file) for name,",
"df = df.sample(n=max_rows, replace=Fa... |
[
"version': sys.version, 'platform': platform.platform(), 'optional deps. installed': optional_deps, } return '\\n'.join('{:>30} {}'.format(k +",
"import_module from pathlib import Path from .main import compiled optional_deps = [] for",
"'_')) except ImportError: continue optional_deps.append(p) info = { 'pydan... |
[
"and Configurable not in obj.__bases__) @classmethod def purge(cls): cls.schemas = {} cls.units =",
"establish a configuration chain.\"\"\" class Registry(object): \"\"\"The unit registry.\"\"\" dependencies = {} schemas",
"Structure __all__ = ('Configurable', 'Registry') class Configurable(object): \"\"\"A sen... |
[
"import * from .group import * from .http import * from .messaging import",
"from .group import * from .http import * from .messaging import * from",
"import * from .database import * from .entrypoint import * from .group import",
".messaging import * from .method import * from .operation import * from .stack... |
[
"== 0: break segmentno = random.choice(range(len(words))) segment = words.pop(segmentno) tokens = segment.split() phrase_index",
"args.len: words = [target] num = args.number choices = {} for i in",
"args.add_eos: target = f\"{target} </s>\" if len(target.split()) >= args.len: words = [target] num",
"= target... |
[
"2020 <NAME> # # Permission is hereby granted, free of charge, to any",
"'--exclude', 'ascii', path]) if self.return_code != 0: raise FileError('\\n'.join(self.stderr)) return '\\n'.join(self.stdout) def is_executable_elf(self,",
"to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copie... |
[
"other urls present on the records if --select-url is given.)\") parser.add_argument(\"--print-pub-date\", action=\"store_true\", help=\"Print",
"h: len(hosts_to_urls[h])) for host in hosts: print(\"% 6d\\t%s\" % (len(hosts_to_urls[host]), host)) def print_urls_for_host(hosts_to_urls:",
"every time this is call... |
[
"writing, software # distributed under the License is distributed on an \"AS IS\"",
"# -------------------------------------------------------------------------------------------------- # Licensed under the Apache License, Version 2.0 (the \"License\"); #",
"the License. # You may obtain a copy of the License i... |
[
"resource['code'] eq_(world.status, HTTP_ACCEPTED) world.location = resource['location'] world.pca = resource['object'] #@step(r'I wait until the",
"Unless required by applicable law or agreed to in writing, software # distributed",
"status = get_status(world.pca) while (status['code'] != int(code1) and status[... |
[
"admins = ['admin1_telegram_nickname', 'admin2_telegram_nickname'] avail_days = [] TOKEN = 'bot_<PASSWORD>' group_id = id_of_group_chat",
"<filename>config.py days_of_week = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday', 'Sunday'] operation = '' options = ['Info', 'Check-in/Out', 'Edit",
"opera... |
[
"return 'yes' in sandwich_builder(), so I made them all cost 0.25 'no':0 #",
"'rye':2.0, 'wheat':1.50, 'white':1.25, 'chicken':2.0, 'turkey':1.50, 'ham':2.0, 'tofu':1.25, 'cheddar':2.0, 'swiss':2.5, 'mozzarella':2.5, 'yes':0.25, # toppings",
"ip.inputChoice(['chicken', 'turkey', 'ham', 'tofu'], prompt=protein_p... |
[
"builder.commands.scode import SCode, SCmd from builder.containers.chapter import Chapter from builder.containers.episode import Episode from",
"(src, expect, exp_opt) (True, Story('test',), ('test',), 1), ] def checker(src, expect, exp_opt): tmp",
"from builder.core import headerupdater as hd class HeaderUpdat... |
[
"import numpy as np import h5py filename = \"test_vlen_datasets_np_bool.h5\" rows = [np.array([np.True_, np.False_]),",
"rows[r] f.flush() f.close() f = h5py.File(filename, 'r') dsetr = f[\"vlen_matrix\"] for r in",
"np.False_]), np.array([np.True_, np.True_, np.False_])] f = h5py.File(filename, 'x') # create f... |
[
"bounds=None): if bounds is None: return (0.0 + a - a.min()) / (a.max()",
"return (imInput, metadata) def writeVideoToFile(imVideo, filename, codec='DIVX', fps=30, isColor=False): # start timer tStart",
"= time.time() print 'Writing video {} took {} seconds'.format(filename, tEnd - tStart) #",
"fmt vmode = vi... |
[
"if not EMAIL_ADDRESS.match(address): return None local, domain = address.split(\"@\", 1) return \"%s@%s\" %",
"from smtplib import SMTP from weasyl import define, macro EMAIL_ADDRESS = re.compile(r\"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+\\Z\") def",
"domain.lower()) def send(mailto, subject, content)... |
[
"def test_builder_reports_warning_for_missing_process(app, status, warning): app.builder.build_all() assert \"build succeeded\" not in status.getvalue() warnings =",
"warning): app.builder.build_all() assert \"build succeeded\" not in status.getvalue() warnings = warning.getvalue().strip() assert 'WARNING:",
"\... |
[
"#find mean value print('\\nMean: ',statistics.mean(level_score)) #find median value print('\\nMediand: ',statistics.median(level_score)) #Mode calculation #create",
"#find median value print('\\nMediand: ',statistics.median(level_score)) #Mode calculation #create numPy array of values with",
"vals, uni_val_cou... |
[
"= conevertandsurface(vcen, r, zlen, deganglestep)# A solid is defined by vertices and surfaces",
"notice = \"\"\" Cone Demo ----------------------------------- | Copyright 2022 by <NAME> | |",
"isSolid = True # toggle solid or outline showoutline = False # can",
"x y z coords r = 40 # radius of cone zlen =",... |
[
"array to store results for plotting rmse = np.ones((25, 2)) noise = 0.01",
"0 n_train = 0 while n_train < 200: n_target = 100 +100*n #",
"as plt from sklearn.preprocessing import StandardScaler from sklearn.gaussian_process import GaussianProcessRegressor from sklearn.gaussian_process.kernels import",
"White... |
[
"This function must be imported and executed from the Python interpreter before the",
"'heat' + codes['temperature'] else: command_postfix = codes['temperature'] codes['command'] = command_postfix return codes def",
"connect_db() @app.teardown_request def teardown_request(exception): db = getattr(g, 'db', None)... |
[
"float: \"\"\"Compute the norm of a vector.\"\"\" return np.sqrt(np.dot(vs, vs)) def create_random_matrix(size: int)",
"\"\"\"Compute the norm of a vector.\"\"\" return np.sqrt(np.dot(vs, vs)) def create_random_matrix(size: int) ->",
"return xs + xs.T def check_eigenpairs( matrix: np.ndarray, eigenvalues: np.nd... |
[
"one: 哈希表 n = len(nums) flag = [False for i in range(n)] for",
"range(1, len(nums)): if pre == nums[i]: return nums[i] else: pre = nums[i] return",
"flag[nums[i]] = True else: return nums[i] return -1 # solution two: 排序 nums.sort()",
"typing import List class Solution: def findRepeatNumber(self, nums: List[in... |
[
"and testing sets so we don't cheat X_train, X_test, y_train, y_test = train_test_split(X,",
"num_obs + ['blue'] * num_obs # plt.figure(figsize=(12,8)) # plt.scatter(X[:, 0], X[:, 1], c",
"y, test_size=0.33, random_state=42) # Create our model network = GWUNetwork() network.add(Dense(2, 1, True,",
"as np impo... |
[
"np.empty(shape=(chunk_length, len(r))) for i in range(chunk_length): g_r_t_final[i, :] = np.mean(g_r_t[i::chunk_length], axis=0) g_r_t_final /=",
"trajectory Parameters ---------- trj : mdtraj.Trajectory trajectory on which to compute the Van",
"coeff = form_factor1 * concentration1 * form_factor2 * concentrat... |
[
"\"alexnet\", \"quant_alexnet\"] from .alexnet import * from .lenet import * from .lenet5 import",
"https://github.com/QDucasse # <EMAIL> from __future__ import absolute_import __all__ = [\"lenet\",\"lenet5\",\"quant_lenet5\", \"quant_cnv\", \"quant_tfc\", \"mobilenetv1\",\"quant_mobilenetv1\",",
"from .mobilen... |
[
"cv.imshow('Gray', gray) # blur = cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT) cv.imshow('Blur', blur) canny = cv.Canny(blur,",
"= cv.GaussianBlur(gray, (5,5), cv.BORDER_DEFAULT) cv.imshow('Blur', blur) canny = cv.Canny(blur, 125, 175) cv.imshow('Canny Edges',",
"cv.CHAIN_APPROX_SIMPLE) print(f'{len(contours... |
[] |
[
"Juve and contributors # For license information, please see license.txt # import frappe",
"license information, please see license.txt # import frappe from frappe.model.document import Document class",
"please see license.txt # import frappe from frappe.model.document import Document class Practitioner(Documen... |
[
"\"/checkstyle_config.xml\")) print(\"Changing permissions for pre-commit. Has to run as root, enter password plz\")",
"import urllib; from urllib.request import urlretrieve from subprocess import call def install_hooks(directory): checkstyleUrl",
"(basePath + \"/.git/hooks/pre-commit\")]) if __name__ == \"__ma... |
[
"the HTTPServer when there is a request to be handled.\"\"\" # Create the",
"class MicroServer(object): \"\"\"Small web server.\"\"\" def __init__(self): \"\"\"Initializes the class and configures the",
"from webob import Request from webob import Response from jinja2 import Environment, FileSystemLoader",
"e... |
[
"django.core import mail from django.conf import settings from django.core.management.base import BaseCommand import amo.utils",
"the Add-on SDK's development. Feedback and engagement from developers like you are the",
"will need to upgrade them to the 1.0 version of the SDK manually.",
"to get in touch with ... |
[
"observer who has constraints ``constraints`` target : {list, `~astropy.coordinates.SkyCoord`, `~astroplan.FixedTarget`} Target times :",
"(containing the supplied ``constraints``). \"\"\" if not hasattr(constraints, '__len__'): constraints = [constraints] is_24hr_table",
"= PhaseConstraint(binary, min=0.4, max... |
[
"def categories(request): context = {} context['nav_active'] = 'categories' categories_list = Category.objects.all() paginator =",
"@login_required() def edit_post(request, post_id): context = {} context['nav_active'] = 'posts' post = Post.objects.get(pk=post_id)",
"PageNotAnInteger: posts = paginator.page(1) e... |
[
"import uuid import zipfile from concurrent.futures import Future from multiprocessing.connection import Connection from",
"= _mp.Process( target=_run_model_session_process, name=\"ModelSessionProcess\", kwargs={\"conn\": server_conn, \"devices\": devices, \"log_queue\": log_queue, \"model_zip\": model_zip}, )",
... |
[
"launch(self, session, event): created = [] entities = event['data']['entities'] for entity in entities:",
"less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me = True",
"must be less than SyncToAvalon event ''' priority = SyncToAvalonEvent.priority - 1 ignore_me",
"of this eve... |
[
"tests.settings_mock as settings_mock from tests.activity.classes_mock import FakeLogger from workflow.workflow_IngestAcceptedSubmission import workflow_IngestAcceptedSubmission class TestWorkflowIngestAcceptedSubmission(unittest.TestCase):",
"unittest import tests.settings_mock as settings_mock from tests.activi... |
[
"vumi_api def token(request, token): # We only need the redis manager here, but",
"the redis manager here, but it's saner to get a whole # vumi_api",
"we need to be if not user_id or request.user.id == user_id: path, _,",
"being forwarded so the view handling the `redirect_to` # can lookup the token",
"but ... |
[
"force_unicode(text) f.is_safe = True out = text try: out = f(text) except TypogrifyError,",
"template.Library() def make_safe(f): \"\"\" A function wrapper to make typogrify play nice with",
"make typogrify play nice with django's unicode support. \"\"\" @wraps(f) def wrapper(text): text",
"f(text) except Ty... |
[
"matrix) # \"4\": Talairach transformation # \"5\": Un-Talairach transformation (1 - 5 ->",
"order to represent large data sets efficiently, e.g. in # the context of",
"mean intensity data, = struct.unpack('<i', f.read(4)) header[\"VMROrigV16MaxValue\"] = data # 16-bit data max",
"header[\"OffsetX\"] = data d... |
[
"an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND,",
"distributed on an # \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY",
"print('Tested %s acc = %f, speed = %f img/sec' % (m, r, speed))",
"express or implied. See the License for the # specific language governing permissions",
... |
[
"sort the data when using TS methods. Returns ------- vDataFrame self.parent See Also",
"be able to solve this issue.\" ) self.add_copy(new_name) parent = self.drop(add_history=False) parent.__add_to_history__( \"[Rename]:",
"the nth most occurent element. Parameters ---------- dropna: bool, optional If set to"... |
[
"= book.reprint form.removed.data = book.removed form.keepsite.data = book.keepsite return render_template('book/edit_book.html', form=form) @book.route('/del/<int:id>', methods=['GET',",
"from booktags.db.basemodels import Book from booktags.flaskapp.model.models import BookMain # -------------------------------... |
[
"= 'text/html' ico = 'image/bmp' jpg = 'image/jpeg' jpeg = 'image/jpeg' js =",
"'application/javascript' png = 'image/png' txt = 'text/plain; charset=us-ascii' json = 'application/json' svg =",
"content_type(Enum): # https://www.iana.org/assignments/media-types/media-types.xhtml css = 'text/css' gif = 'image/gi... |